diff --git a/build/index.js b/build/index.js new file mode 100644 index 0000000..35f9060 --- /dev/null +++ b/build/index.js @@ -0,0 +1,27000 @@ +#!/usr/bin/env node +import { createRequire } from "module"; const require = createRequire(import.meta.url); +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { + get: (a, b) => (typeof require !== "undefined" ? require : a)[b] +}) : x)(function(x) { + if (typeof require !== "undefined") return require.apply(this, arguments); + throw Error('Dynamic require of "' + x + '" is not supported'); +}); +var __commonJS = (cb, mod) => function __require2() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// node_modules/ws/lib/constants.js +var require_constants = __commonJS({ + "node_modules/ws/lib/constants.js"(exports, module) { + "use strict"; + var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"]; + var hasBlob = typeof Blob !== "undefined"; + if (hasBlob) BINARY_TYPES.push("blob"); + module.exports = { + BINARY_TYPES, + CLOSE_TIMEOUT: 3e4, + EMPTY_BUFFER: Buffer.alloc(0), + GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", + hasBlob, + kForOnEventAttribute: Symbol("kIsForOnEventAttribute"), + kListener: Symbol("kListener"), + kStatusCode: Symbol("status-code"), + kWebSocket: Symbol("websocket"), + NOOP: () => { + } + }; + } +}); + +// node_modules/ws/lib/buffer-util.js +var require_buffer_util = __commonJS({ + "node_modules/ws/lib/buffer-util.js"(exports, module) { + "use strict"; + var { EMPTY_BUFFER } = require_constants(); + var FastBuffer = Buffer[Symbol.species]; + function concat(list, totalLength) { + if (list.length === 0) return EMPTY_BUFFER; + if (list.length === 1) return list[0]; + const target = Buffer.allocUnsafe(totalLength); + let offset = 0; + for (let i = 0; i < list.length; i++) { + const buf = list[i]; + target.set(buf, offset); + offset += buf.length; + } + if (offset < totalLength) { + return new FastBuffer(target.buffer, target.byteOffset, offset); + } + return target; + } + function _mask(source, mask, output, offset, length) { + for (let i = 0; i < length; i++) { + output[offset + i] = source[i] ^ mask[i & 3]; + } + } + function _unmask(buffer, mask) { + for (let i = 0; i < buffer.length; i++) { + buffer[i] ^= mask[i & 3]; + } + } + function toArrayBuffer(buf) { + if (buf.length === buf.buffer.byteLength) { + return buf.buffer; + } + return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length); + } + function toBuffer(data) { + toBuffer.readOnly = true; + if (Buffer.isBuffer(data)) return data; + let buf; + if (data instanceof ArrayBuffer) { + buf = new FastBuffer(data); + } else if (ArrayBuffer.isView(data)) { + buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength); + } else { + buf = Buffer.from(data); + toBuffer.readOnly = false; + } + return buf; + } + module.exports = { + concat, + mask: _mask, + toArrayBuffer, + toBuffer, + unmask: _unmask + }; + if (!process.env.WS_NO_BUFFER_UTIL) { + try { + const bufferUtil = __require("bufferutil"); + module.exports.mask = function(source, mask, output, offset, length) { + if (length < 48) _mask(source, mask, output, offset, length); + else bufferUtil.mask(source, mask, output, offset, length); + }; + module.exports.unmask = function(buffer, mask) { + if (buffer.length < 32) _unmask(buffer, mask); + else bufferUtil.unmask(buffer, mask); + }; + } catch (e) { + } + } + } +}); + +// node_modules/ws/lib/limiter.js +var require_limiter = __commonJS({ + "node_modules/ws/lib/limiter.js"(exports, module) { + "use strict"; + var kDone = Symbol("kDone"); + var kRun = Symbol("kRun"); + var Limiter = class { + /** + * Creates a new `Limiter`. + * + * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed + * to run concurrently + */ + constructor(concurrency) { + this[kDone] = () => { + this.pending--; + this[kRun](); + }; + this.concurrency = concurrency || Infinity; + this.jobs = []; + this.pending = 0; + } + /** + * Adds a job to the queue. + * + * @param {Function} job The job to run + * @public + */ + add(job) { + this.jobs.push(job); + this[kRun](); + } + /** + * Removes a job from the queue and runs it if possible. + * + * @private + */ + [kRun]() { + if (this.pending === this.concurrency) return; + if (this.jobs.length) { + const job = this.jobs.shift(); + this.pending++; + job(this[kDone]); + } + } + }; + module.exports = Limiter; + } +}); + +// node_modules/ws/lib/permessage-deflate.js +var require_permessage_deflate = __commonJS({ + "node_modules/ws/lib/permessage-deflate.js"(exports, module) { + "use strict"; + var zlib = __require("zlib"); + var bufferUtil = require_buffer_util(); + var Limiter = require_limiter(); + var { kStatusCode } = require_constants(); + var FastBuffer = Buffer[Symbol.species]; + var TRAILER = Buffer.from([0, 0, 255, 255]); + var kPerMessageDeflate = Symbol("permessage-deflate"); + var kTotalLength = Symbol("total-length"); + var kCallback = Symbol("callback"); + var kBuffers = Symbol("buffers"); + var kError = Symbol("error"); + var zlibLimiter; + var PerMessageDeflate = class { + /** + * Creates a PerMessageDeflate instance. + * + * @param {Object} [options] Configuration options + * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support + * for, or request, a custom client window size + * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/ + * acknowledge disabling of client context takeover + * @param {Number} [options.concurrencyLimit=10] The number of concurrent + * calls to zlib + * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the + * use of a custom server window size + * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept + * disabling of server context takeover + * @param {Number} [options.threshold=1024] Size (in bytes) below which + * messages should not be compressed if context takeover is disabled + * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on + * deflate + * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on + * inflate + * @param {Boolean} [isServer=false] Create the instance in either server or + * client mode + * @param {Number} [maxPayload=0] The maximum allowed message length + */ + constructor(options, isServer, maxPayload) { + this._maxPayload = maxPayload | 0; + this._options = options || {}; + this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024; + this._isServer = !!isServer; + this._deflate = null; + this._inflate = null; + this.params = null; + if (!zlibLimiter) { + const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10; + zlibLimiter = new Limiter(concurrency); + } + } + /** + * @type {String} + */ + static get extensionName() { + return "permessage-deflate"; + } + /** + * Create an extension negotiation offer. + * + * @return {Object} Extension parameters + * @public + */ + offer() { + const params = {}; + if (this._options.serverNoContextTakeover) { + params.server_no_context_takeover = true; + } + if (this._options.clientNoContextTakeover) { + params.client_no_context_takeover = true; + } + if (this._options.serverMaxWindowBits) { + params.server_max_window_bits = this._options.serverMaxWindowBits; + } + if (this._options.clientMaxWindowBits) { + params.client_max_window_bits = this._options.clientMaxWindowBits; + } else if (this._options.clientMaxWindowBits == null) { + params.client_max_window_bits = true; + } + return params; + } + /** + * Accept an extension negotiation offer/response. + * + * @param {Array} configurations The extension negotiation offers/reponse + * @return {Object} Accepted configuration + * @public + */ + accept(configurations) { + configurations = this.normalizeParams(configurations); + this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations); + return this.params; + } + /** + * Releases all resources used by the extension. + * + * @public + */ + cleanup() { + if (this._inflate) { + this._inflate.close(); + this._inflate = null; + } + if (this._deflate) { + const callback = this._deflate[kCallback]; + this._deflate.close(); + this._deflate = null; + if (callback) { + callback( + new Error( + "The deflate stream was closed while data was being processed" + ) + ); + } + } + } + /** + * Accept an extension negotiation offer. + * + * @param {Array} offers The extension negotiation offers + * @return {Object} Accepted configuration + * @private + */ + acceptAsServer(offers) { + const opts = this._options; + const accepted = offers.find((params) => { + if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) { + return false; + } + return true; + }); + if (!accepted) { + throw new Error("None of the extension offers can be accepted"); + } + if (opts.serverNoContextTakeover) { + accepted.server_no_context_takeover = true; + } + if (opts.clientNoContextTakeover) { + accepted.client_no_context_takeover = true; + } + if (typeof opts.serverMaxWindowBits === "number") { + accepted.server_max_window_bits = opts.serverMaxWindowBits; + } + if (typeof opts.clientMaxWindowBits === "number") { + accepted.client_max_window_bits = opts.clientMaxWindowBits; + } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) { + delete accepted.client_max_window_bits; + } + return accepted; + } + /** + * Accept the extension negotiation response. + * + * @param {Array} response The extension negotiation response + * @return {Object} Accepted configuration + * @private + */ + acceptAsClient(response) { + const params = response[0]; + if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) { + throw new Error('Unexpected parameter "client_no_context_takeover"'); + } + if (!params.client_max_window_bits) { + if (typeof this._options.clientMaxWindowBits === "number") { + params.client_max_window_bits = this._options.clientMaxWindowBits; + } + } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) { + throw new Error( + 'Unexpected or invalid parameter "client_max_window_bits"' + ); + } + return params; + } + /** + * Normalize parameters. + * + * @param {Array} configurations The extension negotiation offers/reponse + * @return {Array} The offers/response with normalized parameters + * @private + */ + normalizeParams(configurations) { + configurations.forEach((params) => { + Object.keys(params).forEach((key) => { + let value = params[key]; + if (value.length > 1) { + throw new Error(`Parameter "${key}" must have only a single value`); + } + value = value[0]; + if (key === "client_max_window_bits") { + if (value !== true) { + const num = +value; + if (!Number.isInteger(num) || num < 8 || num > 15) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + value = num; + } else if (!this._isServer) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + } else if (key === "server_max_window_bits") { + const num = +value; + if (!Number.isInteger(num) || num < 8 || num > 15) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + value = num; + } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") { + if (value !== true) { + throw new TypeError( + `Invalid value for parameter "${key}": ${value}` + ); + } + } else { + throw new Error(`Unknown parameter "${key}"`); + } + params[key] = value; + }); + }); + return configurations; + } + /** + * Decompress data. Concurrency limited. + * + * @param {Buffer} data Compressed data + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @public + */ + decompress(data, fin, callback) { + zlibLimiter.add((done) => { + this._decompress(data, fin, (err, result) => { + done(); + callback(err, result); + }); + }); + } + /** + * Compress data. Concurrency limited. + * + * @param {(Buffer|String)} data Data to compress + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @public + */ + compress(data, fin, callback) { + zlibLimiter.add((done) => { + this._compress(data, fin, (err, result) => { + done(); + callback(err, result); + }); + }); + } + /** + * Decompress data. + * + * @param {Buffer} data Compressed data + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @private + */ + _decompress(data, fin, callback) { + const endpoint = this._isServer ? "client" : "server"; + if (!this._inflate) { + const key = `${endpoint}_max_window_bits`; + const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key]; + this._inflate = zlib.createInflateRaw({ + ...this._options.zlibInflateOptions, + windowBits + }); + this._inflate[kPerMessageDeflate] = this; + this._inflate[kTotalLength] = 0; + this._inflate[kBuffers] = []; + this._inflate.on("error", inflateOnError); + this._inflate.on("data", inflateOnData); + } + this._inflate[kCallback] = callback; + this._inflate.write(data); + if (fin) this._inflate.write(TRAILER); + this._inflate.flush(() => { + const err = this._inflate[kError]; + if (err) { + this._inflate.close(); + this._inflate = null; + callback(err); + return; + } + const data2 = bufferUtil.concat( + this._inflate[kBuffers], + this._inflate[kTotalLength] + ); + if (this._inflate._readableState.endEmitted) { + this._inflate.close(); + this._inflate = null; + } else { + this._inflate[kTotalLength] = 0; + this._inflate[kBuffers] = []; + if (fin && this.params[`${endpoint}_no_context_takeover`]) { + this._inflate.reset(); + } + } + callback(null, data2); + }); + } + /** + * Compress data. + * + * @param {(Buffer|String)} data Data to compress + * @param {Boolean} fin Specifies whether or not this is the last fragment + * @param {Function} callback Callback + * @private + */ + _compress(data, fin, callback) { + const endpoint = this._isServer ? "server" : "client"; + if (!this._deflate) { + const key = `${endpoint}_max_window_bits`; + const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key]; + this._deflate = zlib.createDeflateRaw({ + ...this._options.zlibDeflateOptions, + windowBits + }); + this._deflate[kTotalLength] = 0; + this._deflate[kBuffers] = []; + this._deflate.on("data", deflateOnData); + } + this._deflate[kCallback] = callback; + this._deflate.write(data); + this._deflate.flush(zlib.Z_SYNC_FLUSH, () => { + if (!this._deflate) { + return; + } + let data2 = bufferUtil.concat( + this._deflate[kBuffers], + this._deflate[kTotalLength] + ); + if (fin) { + data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4); + } + this._deflate[kCallback] = null; + this._deflate[kTotalLength] = 0; + this._deflate[kBuffers] = []; + if (fin && this.params[`${endpoint}_no_context_takeover`]) { + this._deflate.reset(); + } + callback(null, data2); + }); + } + }; + module.exports = PerMessageDeflate; + function deflateOnData(chunk) { + this[kBuffers].push(chunk); + this[kTotalLength] += chunk.length; + } + function inflateOnData(chunk) { + this[kTotalLength] += chunk.length; + if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) { + this[kBuffers].push(chunk); + return; + } + this[kError] = new RangeError("Max payload size exceeded"); + this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"; + this[kError][kStatusCode] = 1009; + this.removeListener("data", inflateOnData); + this.reset(); + } + function inflateOnError(err) { + this[kPerMessageDeflate]._inflate = null; + if (this[kError]) { + this[kCallback](this[kError]); + return; + } + err[kStatusCode] = 1007; + this[kCallback](err); + } + } +}); + +// node_modules/ws/lib/validation.js +var require_validation = __commonJS({ + "node_modules/ws/lib/validation.js"(exports, module) { + "use strict"; + var { isUtf8 } = __require("buffer"); + var { hasBlob } = require_constants(); + var tokenChars = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + // 0 - 15 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + // 16 - 31 + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + // 32 - 47 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + // 48 - 63 + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + // 64 - 79 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + // 80 - 95 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + // 96 - 111 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 0, + 1, + 0 + // 112 - 127 + ]; + function isValidStatusCode(code) { + return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999; + } + function _isValidUTF8(buf) { + const len = buf.length; + let i = 0; + while (i < len) { + if ((buf[i] & 128) === 0) { + i++; + } else if ((buf[i] & 224) === 192) { + if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) { + return false; + } + i += 2; + } else if ((buf[i] & 240) === 224) { + if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong + buf[i] === 237 && (buf[i + 1] & 224) === 160) { + return false; + } + i += 3; + } else if ((buf[i] & 248) === 240) { + if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || // Overlong + buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) { + return false; + } + i += 4; + } else { + return false; + } + } + return true; + } + function isBlob(value) { + return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File"); + } + module.exports = { + isBlob, + isValidStatusCode, + isValidUTF8: _isValidUTF8, + tokenChars + }; + if (isUtf8) { + module.exports.isValidUTF8 = function(buf) { + return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf); + }; + } else if (!process.env.WS_NO_UTF_8_VALIDATE) { + try { + const isValidUTF8 = __require("utf-8-validate"); + module.exports.isValidUTF8 = function(buf) { + return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf); + }; + } catch (e) { + } + } + } +}); + +// node_modules/ws/lib/receiver.js +var require_receiver = __commonJS({ + "node_modules/ws/lib/receiver.js"(exports, module) { + "use strict"; + var { Writable } = __require("stream"); + var PerMessageDeflate = require_permessage_deflate(); + var { + BINARY_TYPES, + EMPTY_BUFFER, + kStatusCode, + kWebSocket + } = require_constants(); + var { concat, toArrayBuffer, unmask } = require_buffer_util(); + var { isValidStatusCode, isValidUTF8 } = require_validation(); + var FastBuffer = Buffer[Symbol.species]; + var GET_INFO = 0; + var GET_PAYLOAD_LENGTH_16 = 1; + var GET_PAYLOAD_LENGTH_64 = 2; + var GET_MASK = 3; + var GET_DATA = 4; + var INFLATING = 5; + var DEFER_EVENT = 6; + var Receiver2 = class extends Writable { + /** + * Creates a Receiver instance. + * + * @param {Object} [options] Options object + * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {String} [options.binaryType=nodebuffer] The type for binary data + * @param {Object} [options.extensions] An object containing the negotiated + * extensions + * @param {Boolean} [options.isServer=false] Specifies whether to operate in + * client or server mode + * @param {Number} [options.maxPayload=0] The maximum allowed message length + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + */ + constructor(options = {}) { + super(); + this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true; + this._binaryType = options.binaryType || BINARY_TYPES[0]; + this._extensions = options.extensions || {}; + this._isServer = !!options.isServer; + this._maxPayload = options.maxPayload | 0; + this._skipUTF8Validation = !!options.skipUTF8Validation; + this[kWebSocket] = void 0; + this._bufferedBytes = 0; + this._buffers = []; + this._compressed = false; + this._payloadLength = 0; + this._mask = void 0; + this._fragmented = 0; + this._masked = false; + this._fin = false; + this._opcode = 0; + this._totalPayloadLength = 0; + this._messageLength = 0; + this._fragments = []; + this._errored = false; + this._loop = false; + this._state = GET_INFO; + } + /** + * Implements `Writable.prototype._write()`. + * + * @param {Buffer} chunk The chunk of data to write + * @param {String} encoding The character encoding of `chunk` + * @param {Function} cb Callback + * @private + */ + _write(chunk, encoding, cb) { + if (this._opcode === 8 && this._state == GET_INFO) return cb(); + this._bufferedBytes += chunk.length; + this._buffers.push(chunk); + this.startLoop(cb); + } + /** + * Consumes `n` bytes from the buffered data. + * + * @param {Number} n The number of bytes to consume + * @return {Buffer} The consumed bytes + * @private + */ + consume(n) { + this._bufferedBytes -= n; + if (n === this._buffers[0].length) return this._buffers.shift(); + if (n < this._buffers[0].length) { + const buf = this._buffers[0]; + this._buffers[0] = new FastBuffer( + buf.buffer, + buf.byteOffset + n, + buf.length - n + ); + return new FastBuffer(buf.buffer, buf.byteOffset, n); + } + const dst = Buffer.allocUnsafe(n); + do { + const buf = this._buffers[0]; + const offset = dst.length - n; + if (n >= buf.length) { + dst.set(this._buffers.shift(), offset); + } else { + dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset); + this._buffers[0] = new FastBuffer( + buf.buffer, + buf.byteOffset + n, + buf.length - n + ); + } + n -= buf.length; + } while (n > 0); + return dst; + } + /** + * Starts the parsing loop. + * + * @param {Function} cb Callback + * @private + */ + startLoop(cb) { + this._loop = true; + do { + switch (this._state) { + case GET_INFO: + this.getInfo(cb); + break; + case GET_PAYLOAD_LENGTH_16: + this.getPayloadLength16(cb); + break; + case GET_PAYLOAD_LENGTH_64: + this.getPayloadLength64(cb); + break; + case GET_MASK: + this.getMask(); + break; + case GET_DATA: + this.getData(cb); + break; + case INFLATING: + case DEFER_EVENT: + this._loop = false; + return; + } + } while (this._loop); + if (!this._errored) cb(); + } + /** + * Reads the first two bytes of a frame. + * + * @param {Function} cb Callback + * @private + */ + getInfo(cb) { + if (this._bufferedBytes < 2) { + this._loop = false; + return; + } + const buf = this.consume(2); + if ((buf[0] & 48) !== 0) { + const error2 = this.createError( + RangeError, + "RSV2 and RSV3 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_2_3" + ); + cb(error2); + return; + } + const compressed = (buf[0] & 64) === 64; + if (compressed && !this._extensions[PerMessageDeflate.extensionName]) { + const error2 = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error2); + return; + } + this._fin = (buf[0] & 128) === 128; + this._opcode = buf[0] & 15; + this._payloadLength = buf[1] & 127; + if (this._opcode === 0) { + if (compressed) { + const error2 = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error2); + return; + } + if (!this._fragmented) { + const error2 = this.createError( + RangeError, + "invalid opcode 0", + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error2); + return; + } + this._opcode = this._fragmented; + } else if (this._opcode === 1 || this._opcode === 2) { + if (this._fragmented) { + const error2 = this.createError( + RangeError, + `invalid opcode ${this._opcode}`, + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error2); + return; + } + this._compressed = compressed; + } else if (this._opcode > 7 && this._opcode < 11) { + if (!this._fin) { + const error2 = this.createError( + RangeError, + "FIN must be set", + true, + 1002, + "WS_ERR_EXPECTED_FIN" + ); + cb(error2); + return; + } + if (compressed) { + const error2 = this.createError( + RangeError, + "RSV1 must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_RSV_1" + ); + cb(error2); + return; + } + if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) { + const error2 = this.createError( + RangeError, + `invalid payload length ${this._payloadLength}`, + true, + 1002, + "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH" + ); + cb(error2); + return; + } + } else { + const error2 = this.createError( + RangeError, + `invalid opcode ${this._opcode}`, + true, + 1002, + "WS_ERR_INVALID_OPCODE" + ); + cb(error2); + return; + } + if (!this._fin && !this._fragmented) this._fragmented = this._opcode; + this._masked = (buf[1] & 128) === 128; + if (this._isServer) { + if (!this._masked) { + const error2 = this.createError( + RangeError, + "MASK must be set", + true, + 1002, + "WS_ERR_EXPECTED_MASK" + ); + cb(error2); + return; + } + } else if (this._masked) { + const error2 = this.createError( + RangeError, + "MASK must be clear", + true, + 1002, + "WS_ERR_UNEXPECTED_MASK" + ); + cb(error2); + return; + } + if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16; + else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64; + else this.haveLength(cb); + } + /** + * Gets extended payload length (7+16). + * + * @param {Function} cb Callback + * @private + */ + getPayloadLength16(cb) { + if (this._bufferedBytes < 2) { + this._loop = false; + return; + } + this._payloadLength = this.consume(2).readUInt16BE(0); + this.haveLength(cb); + } + /** + * Gets extended payload length (7+64). + * + * @param {Function} cb Callback + * @private + */ + getPayloadLength64(cb) { + if (this._bufferedBytes < 8) { + this._loop = false; + return; + } + const buf = this.consume(8); + const num = buf.readUInt32BE(0); + if (num > Math.pow(2, 53 - 32) - 1) { + const error2 = this.createError( + RangeError, + "Unsupported WebSocket frame: payload length > 2^53 - 1", + false, + 1009, + "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH" + ); + cb(error2); + return; + } + this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4); + this.haveLength(cb); + } + /** + * Payload length has been read. + * + * @param {Function} cb Callback + * @private + */ + haveLength(cb) { + if (this._payloadLength && this._opcode < 8) { + this._totalPayloadLength += this._payloadLength; + if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) { + const error2 = this.createError( + RangeError, + "Max payload size exceeded", + false, + 1009, + "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" + ); + cb(error2); + return; + } + } + if (this._masked) this._state = GET_MASK; + else this._state = GET_DATA; + } + /** + * Reads mask bytes. + * + * @private + */ + getMask() { + if (this._bufferedBytes < 4) { + this._loop = false; + return; + } + this._mask = this.consume(4); + this._state = GET_DATA; + } + /** + * Reads data bytes. + * + * @param {Function} cb Callback + * @private + */ + getData(cb) { + let data = EMPTY_BUFFER; + if (this._payloadLength) { + if (this._bufferedBytes < this._payloadLength) { + this._loop = false; + return; + } + data = this.consume(this._payloadLength); + if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) { + unmask(data, this._mask); + } + } + if (this._opcode > 7) { + this.controlMessage(data, cb); + return; + } + if (this._compressed) { + this._state = INFLATING; + this.decompress(data, cb); + return; + } + if (data.length) { + this._messageLength = this._totalPayloadLength; + this._fragments.push(data); + } + this.dataMessage(cb); + } + /** + * Decompresses data. + * + * @param {Buffer} data Compressed data + * @param {Function} cb Callback + * @private + */ + decompress(data, cb) { + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + perMessageDeflate.decompress(data, this._fin, (err, buf) => { + if (err) return cb(err); + if (buf.length) { + this._messageLength += buf.length; + if (this._messageLength > this._maxPayload && this._maxPayload > 0) { + const error2 = this.createError( + RangeError, + "Max payload size exceeded", + false, + 1009, + "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" + ); + cb(error2); + return; + } + this._fragments.push(buf); + } + this.dataMessage(cb); + if (this._state === GET_INFO) this.startLoop(cb); + }); + } + /** + * Handles a data message. + * + * @param {Function} cb Callback + * @private + */ + dataMessage(cb) { + if (!this._fin) { + this._state = GET_INFO; + return; + } + const messageLength = this._messageLength; + const fragments = this._fragments; + this._totalPayloadLength = 0; + this._messageLength = 0; + this._fragmented = 0; + this._fragments = []; + if (this._opcode === 2) { + let data; + if (this._binaryType === "nodebuffer") { + data = concat(fragments, messageLength); + } else if (this._binaryType === "arraybuffer") { + data = toArrayBuffer(concat(fragments, messageLength)); + } else if (this._binaryType === "blob") { + data = new Blob(fragments); + } else { + data = fragments; + } + if (this._allowSynchronousEvents) { + this.emit("message", data, true); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit("message", data, true); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } else { + const buf = concat(fragments, messageLength); + if (!this._skipUTF8Validation && !isValidUTF8(buf)) { + const error2 = this.createError( + Error, + "invalid UTF-8 sequence", + true, + 1007, + "WS_ERR_INVALID_UTF8" + ); + cb(error2); + return; + } + if (this._state === INFLATING || this._allowSynchronousEvents) { + this.emit("message", buf, false); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit("message", buf, false); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } + } + /** + * Handles a control message. + * + * @param {Buffer} data Data to handle + * @return {(Error|RangeError|undefined)} A possible error + * @private + */ + controlMessage(data, cb) { + if (this._opcode === 8) { + if (data.length === 0) { + this._loop = false; + this.emit("conclude", 1005, EMPTY_BUFFER); + this.end(); + } else { + const code = data.readUInt16BE(0); + if (!isValidStatusCode(code)) { + const error2 = this.createError( + RangeError, + `invalid status code ${code}`, + true, + 1002, + "WS_ERR_INVALID_CLOSE_CODE" + ); + cb(error2); + return; + } + const buf = new FastBuffer( + data.buffer, + data.byteOffset + 2, + data.length - 2 + ); + if (!this._skipUTF8Validation && !isValidUTF8(buf)) { + const error2 = this.createError( + Error, + "invalid UTF-8 sequence", + true, + 1007, + "WS_ERR_INVALID_UTF8" + ); + cb(error2); + return; + } + this._loop = false; + this.emit("conclude", code, buf); + this.end(); + } + this._state = GET_INFO; + return; + } + if (this._allowSynchronousEvents) { + this.emit(this._opcode === 9 ? "ping" : "pong", data); + this._state = GET_INFO; + } else { + this._state = DEFER_EVENT; + setImmediate(() => { + this.emit(this._opcode === 9 ? "ping" : "pong", data); + this._state = GET_INFO; + this.startLoop(cb); + }); + } + } + /** + * Builds an error object. + * + * @param {function(new:Error|RangeError)} ErrorCtor The error constructor + * @param {String} message The error message + * @param {Boolean} prefix Specifies whether or not to add a default prefix to + * `message` + * @param {Number} statusCode The status code + * @param {String} errorCode The exposed error code + * @return {(Error|RangeError)} The error + * @private + */ + createError(ErrorCtor, message, prefix, statusCode, errorCode) { + this._loop = false; + this._errored = true; + const err = new ErrorCtor( + prefix ? `Invalid WebSocket frame: ${message}` : message + ); + Error.captureStackTrace(err, this.createError); + err.code = errorCode; + err[kStatusCode] = statusCode; + return err; + } + }; + module.exports = Receiver2; + } +}); + +// node_modules/ws/lib/sender.js +var require_sender = __commonJS({ + "node_modules/ws/lib/sender.js"(exports, module) { + "use strict"; + var { Duplex } = __require("stream"); + var { randomFillSync } = __require("crypto"); + var PerMessageDeflate = require_permessage_deflate(); + var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants(); + var { isBlob, isValidStatusCode } = require_validation(); + var { mask: applyMask, toBuffer } = require_buffer_util(); + var kByteLength = Symbol("kByteLength"); + var maskBuffer = Buffer.alloc(4); + var RANDOM_POOL_SIZE = 8 * 1024; + var randomPool; + var randomPoolPointer = RANDOM_POOL_SIZE; + var DEFAULT = 0; + var DEFLATING = 1; + var GET_BLOB_DATA = 2; + var Sender2 = class _Sender { + /** + * Creates a Sender instance. + * + * @param {Duplex} socket The connection socket + * @param {Object} [extensions] An object containing the negotiated extensions + * @param {Function} [generateMask] The function used to generate the masking + * key + */ + constructor(socket, extensions, generateMask) { + this._extensions = extensions || {}; + if (generateMask) { + this._generateMask = generateMask; + this._maskBuffer = Buffer.alloc(4); + } + this._socket = socket; + this._firstFragment = true; + this._compress = false; + this._bufferedBytes = 0; + this._queue = []; + this._state = DEFAULT; + this.onerror = NOOP; + this[kWebSocket] = void 0; + } + /** + * Frames a piece of data according to the HyBi WebSocket protocol. + * + * @param {(Buffer|String)} data The data to frame + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @return {(Buffer|String)[]} The framed data + * @public + */ + static frame(data, options) { + let mask; + let merge2 = false; + let offset = 2; + let skipMasking = false; + if (options.mask) { + mask = options.maskBuffer || maskBuffer; + if (options.generateMask) { + options.generateMask(mask); + } else { + if (randomPoolPointer === RANDOM_POOL_SIZE) { + if (randomPool === void 0) { + randomPool = Buffer.alloc(RANDOM_POOL_SIZE); + } + randomFillSync(randomPool, 0, RANDOM_POOL_SIZE); + randomPoolPointer = 0; + } + mask[0] = randomPool[randomPoolPointer++]; + mask[1] = randomPool[randomPoolPointer++]; + mask[2] = randomPool[randomPoolPointer++]; + mask[3] = randomPool[randomPoolPointer++]; + } + skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0; + offset = 6; + } + let dataLength; + if (typeof data === "string") { + if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) { + dataLength = options[kByteLength]; + } else { + data = Buffer.from(data); + dataLength = data.length; + } + } else { + dataLength = data.length; + merge2 = options.mask && options.readOnly && !skipMasking; + } + let payloadLength = dataLength; + if (dataLength >= 65536) { + offset += 8; + payloadLength = 127; + } else if (dataLength > 125) { + offset += 2; + payloadLength = 126; + } + const target = Buffer.allocUnsafe(merge2 ? dataLength + offset : offset); + target[0] = options.fin ? options.opcode | 128 : options.opcode; + if (options.rsv1) target[0] |= 64; + target[1] = payloadLength; + if (payloadLength === 126) { + target.writeUInt16BE(dataLength, 2); + } else if (payloadLength === 127) { + target[2] = target[3] = 0; + target.writeUIntBE(dataLength, 4, 6); + } + if (!options.mask) return [target, data]; + target[1] |= 128; + target[offset - 4] = mask[0]; + target[offset - 3] = mask[1]; + target[offset - 2] = mask[2]; + target[offset - 1] = mask[3]; + if (skipMasking) return [target, data]; + if (merge2) { + applyMask(data, mask, target, offset, dataLength); + return [target]; + } + applyMask(data, mask, data, 0, dataLength); + return [target, data]; + } + /** + * Sends a close message to the other peer. + * + * @param {Number} [code] The status code component of the body + * @param {(String|Buffer)} [data] The message component of the body + * @param {Boolean} [mask=false] Specifies whether or not to mask the message + * @param {Function} [cb] Callback + * @public + */ + close(code, data, mask, cb) { + let buf; + if (code === void 0) { + buf = EMPTY_BUFFER; + } else if (typeof code !== "number" || !isValidStatusCode(code)) { + throw new TypeError("First argument must be a valid error code number"); + } else if (data === void 0 || !data.length) { + buf = Buffer.allocUnsafe(2); + buf.writeUInt16BE(code, 0); + } else { + const length = Buffer.byteLength(data); + if (length > 123) { + throw new RangeError("The message must not be greater than 123 bytes"); + } + buf = Buffer.allocUnsafe(2 + length); + buf.writeUInt16BE(code, 0); + if (typeof data === "string") { + buf.write(data, 2); + } else { + buf.set(data, 2); + } + } + const options = { + [kByteLength]: buf.length, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 8, + readOnly: false, + rsv1: false + }; + if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, buf, false, options, cb]); + } else { + this.sendFrame(_Sender.frame(buf, options), cb); + } + } + /** + * Sends a ping message to the other peer. + * + * @param {*} data The message to send + * @param {Boolean} [mask=false] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback + * @public + */ + ping(data, mask, cb) { + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (byteLength > 125) { + throw new RangeError("The data size must not be greater than 125 bytes"); + } + const options = { + [kByteLength]: byteLength, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 9, + readOnly, + rsv1: false + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, false, options, cb]); + } else { + this.getBlobData(data, false, options, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, false, options, cb]); + } else { + this.sendFrame(_Sender.frame(data, options), cb); + } + } + /** + * Sends a pong message to the other peer. + * + * @param {*} data The message to send + * @param {Boolean} [mask=false] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback + * @public + */ + pong(data, mask, cb) { + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (byteLength > 125) { + throw new RangeError("The data size must not be greater than 125 bytes"); + } + const options = { + [kByteLength]: byteLength, + fin: true, + generateMask: this._generateMask, + mask, + maskBuffer: this._maskBuffer, + opcode: 10, + readOnly, + rsv1: false + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, false, options, cb]); + } else { + this.getBlobData(data, false, options, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, false, options, cb]); + } else { + this.sendFrame(_Sender.frame(data, options), cb); + } + } + /** + * Sends a data message to the other peer. + * + * @param {*} data The message to send + * @param {Object} options Options object + * @param {Boolean} [options.binary=false] Specifies whether `data` is binary + * or text + * @param {Boolean} [options.compress=false] Specifies whether or not to + * compress `data` + * @param {Boolean} [options.fin=false] Specifies whether the fragment is the + * last one + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Function} [cb] Callback + * @public + */ + send(data, options, cb) { + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + let opcode = options.binary ? 2 : 1; + let rsv1 = options.compress; + let byteLength; + let readOnly; + if (typeof data === "string") { + byteLength = Buffer.byteLength(data); + readOnly = false; + } else if (isBlob(data)) { + byteLength = data.size; + readOnly = false; + } else { + data = toBuffer(data); + byteLength = data.length; + readOnly = toBuffer.readOnly; + } + if (this._firstFragment) { + this._firstFragment = false; + if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) { + rsv1 = byteLength >= perMessageDeflate._threshold; + } + this._compress = rsv1; + } else { + rsv1 = false; + opcode = 0; + } + if (options.fin) this._firstFragment = true; + const opts = { + [kByteLength]: byteLength, + fin: options.fin, + generateMask: this._generateMask, + mask: options.mask, + maskBuffer: this._maskBuffer, + opcode, + readOnly, + rsv1 + }; + if (isBlob(data)) { + if (this._state !== DEFAULT) { + this.enqueue([this.getBlobData, data, this._compress, opts, cb]); + } else { + this.getBlobData(data, this._compress, opts, cb); + } + } else if (this._state !== DEFAULT) { + this.enqueue([this.dispatch, data, this._compress, opts, cb]); + } else { + this.dispatch(data, this._compress, opts, cb); + } + } + /** + * Gets the contents of a blob as binary data. + * + * @param {Blob} blob The blob + * @param {Boolean} [compress=false] Specifies whether or not to compress + * the data + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @param {Function} [cb] Callback + * @private + */ + getBlobData(blob, compress, options, cb) { + this._bufferedBytes += options[kByteLength]; + this._state = GET_BLOB_DATA; + blob.arrayBuffer().then((arrayBuffer) => { + if (this._socket.destroyed) { + const err = new Error( + "The socket was closed while the blob was being read" + ); + process.nextTick(callCallbacks, this, err, cb); + return; + } + this._bufferedBytes -= options[kByteLength]; + const data = toBuffer(arrayBuffer); + if (!compress) { + this._state = DEFAULT; + this.sendFrame(_Sender.frame(data, options), cb); + this.dequeue(); + } else { + this.dispatch(data, compress, options, cb); + } + }).catch((err) => { + process.nextTick(onError, this, err, cb); + }); + } + /** + * Dispatches a message. + * + * @param {(Buffer|String)} data The message to send + * @param {Boolean} [compress=false] Specifies whether or not to compress + * `data` + * @param {Object} options Options object + * @param {Boolean} [options.fin=false] Specifies whether or not to set the + * FIN bit + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Boolean} [options.mask=false] Specifies whether or not to mask + * `data` + * @param {Buffer} [options.maskBuffer] The buffer used to store the masking + * key + * @param {Number} options.opcode The opcode + * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be + * modified + * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the + * RSV1 bit + * @param {Function} [cb] Callback + * @private + */ + dispatch(data, compress, options, cb) { + if (!compress) { + this.sendFrame(_Sender.frame(data, options), cb); + return; + } + const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName]; + this._bufferedBytes += options[kByteLength]; + this._state = DEFLATING; + perMessageDeflate.compress(data, options.fin, (_, buf) => { + if (this._socket.destroyed) { + const err = new Error( + "The socket was closed while data was being compressed" + ); + callCallbacks(this, err, cb); + return; + } + this._bufferedBytes -= options[kByteLength]; + this._state = DEFAULT; + options.readOnly = false; + this.sendFrame(_Sender.frame(buf, options), cb); + this.dequeue(); + }); + } + /** + * Executes queued send operations. + * + * @private + */ + dequeue() { + while (this._state === DEFAULT && this._queue.length) { + const params = this._queue.shift(); + this._bufferedBytes -= params[3][kByteLength]; + Reflect.apply(params[0], this, params.slice(1)); + } + } + /** + * Enqueues a send operation. + * + * @param {Array} params Send operation parameters. + * @private + */ + enqueue(params) { + this._bufferedBytes += params[3][kByteLength]; + this._queue.push(params); + } + /** + * Sends a frame. + * + * @param {(Buffer | String)[]} list The frame to send + * @param {Function} [cb] Callback + * @private + */ + sendFrame(list, cb) { + if (list.length === 2) { + this._socket.cork(); + this._socket.write(list[0]); + this._socket.write(list[1], cb); + this._socket.uncork(); + } else { + this._socket.write(list[0], cb); + } + } + }; + module.exports = Sender2; + function callCallbacks(sender, err, cb) { + if (typeof cb === "function") cb(err); + for (let i = 0; i < sender._queue.length; i++) { + const params = sender._queue[i]; + const callback = params[params.length - 1]; + if (typeof callback === "function") callback(err); + } + } + function onError(sender, err, cb) { + callCallbacks(sender, err, cb); + sender.onerror(err); + } + } +}); + +// node_modules/ws/lib/event-target.js +var require_event_target = __commonJS({ + "node_modules/ws/lib/event-target.js"(exports, module) { + "use strict"; + var { kForOnEventAttribute, kListener } = require_constants(); + var kCode = Symbol("kCode"); + var kData = Symbol("kData"); + var kError = Symbol("kError"); + var kMessage = Symbol("kMessage"); + var kReason = Symbol("kReason"); + var kTarget = Symbol("kTarget"); + var kType = Symbol("kType"); + var kWasClean = Symbol("kWasClean"); + var Event = class { + /** + * Create a new `Event`. + * + * @param {String} type The name of the event + * @throws {TypeError} If the `type` argument is not specified + */ + constructor(type) { + this[kTarget] = null; + this[kType] = type; + } + /** + * @type {*} + */ + get target() { + return this[kTarget]; + } + /** + * @type {String} + */ + get type() { + return this[kType]; + } + }; + Object.defineProperty(Event.prototype, "target", { enumerable: true }); + Object.defineProperty(Event.prototype, "type", { enumerable: true }); + var CloseEvent = class extends Event { + /** + * Create a new `CloseEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {Number} [options.code=0] The status code explaining why the + * connection was closed + * @param {String} [options.reason=''] A human-readable string explaining why + * the connection was closed + * @param {Boolean} [options.wasClean=false] Indicates whether or not the + * connection was cleanly closed + */ + constructor(type, options = {}) { + super(type); + this[kCode] = options.code === void 0 ? 0 : options.code; + this[kReason] = options.reason === void 0 ? "" : options.reason; + this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean; + } + /** + * @type {Number} + */ + get code() { + return this[kCode]; + } + /** + * @type {String} + */ + get reason() { + return this[kReason]; + } + /** + * @type {Boolean} + */ + get wasClean() { + return this[kWasClean]; + } + }; + Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true }); + Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true }); + Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true }); + var ErrorEvent = class extends Event { + /** + * Create a new `ErrorEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {*} [options.error=null] The error that generated this event + * @param {String} [options.message=''] The error message + */ + constructor(type, options = {}) { + super(type); + this[kError] = options.error === void 0 ? null : options.error; + this[kMessage] = options.message === void 0 ? "" : options.message; + } + /** + * @type {*} + */ + get error() { + return this[kError]; + } + /** + * @type {String} + */ + get message() { + return this[kMessage]; + } + }; + Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true }); + Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true }); + var MessageEvent = class extends Event { + /** + * Create a new `MessageEvent`. + * + * @param {String} type The name of the event + * @param {Object} [options] A dictionary object that allows for setting + * attributes via object members of the same name + * @param {*} [options.data=null] The message content + */ + constructor(type, options = {}) { + super(type); + this[kData] = options.data === void 0 ? null : options.data; + } + /** + * @type {*} + */ + get data() { + return this[kData]; + } + }; + Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true }); + var EventTarget = { + /** + * Register an event listener. + * + * @param {String} type A string representing the event type to listen for + * @param {(Function|Object)} handler The listener to add + * @param {Object} [options] An options object specifies characteristics about + * the event listener + * @param {Boolean} [options.once=false] A `Boolean` indicating that the + * listener should be invoked at most once after being added. If `true`, + * the listener would be automatically removed when invoked. + * @public + */ + addEventListener(type, handler, options = {}) { + for (const listener of this.listeners(type)) { + if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) { + return; + } + } + let wrapper; + if (type === "message") { + wrapper = function onMessage(data, isBinary) { + const event = new MessageEvent("message", { + data: isBinary ? data : data.toString() + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type === "close") { + wrapper = function onClose(code, message) { + const event = new CloseEvent("close", { + code, + reason: message.toString(), + wasClean: this._closeFrameReceived && this._closeFrameSent + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type === "error") { + wrapper = function onError(error2) { + const event = new ErrorEvent("error", { + error: error2, + message: error2.message + }); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else if (type === "open") { + wrapper = function onOpen() { + const event = new Event("open"); + event[kTarget] = this; + callListener(handler, this, event); + }; + } else { + return; + } + wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute]; + wrapper[kListener] = handler; + if (options.once) { + this.once(type, wrapper); + } else { + this.on(type, wrapper); + } + }, + /** + * Remove an event listener. + * + * @param {String} type A string representing the event type to remove + * @param {(Function|Object)} handler The listener to remove + * @public + */ + removeEventListener(type, handler) { + for (const listener of this.listeners(type)) { + if (listener[kListener] === handler && !listener[kForOnEventAttribute]) { + this.removeListener(type, listener); + break; + } + } + } + }; + module.exports = { + CloseEvent, + ErrorEvent, + Event, + EventTarget, + MessageEvent + }; + function callListener(listener, thisArg, event) { + if (typeof listener === "object" && listener.handleEvent) { + listener.handleEvent.call(listener, event); + } else { + listener.call(thisArg, event); + } + } + } +}); + +// node_modules/ws/lib/extension.js +var require_extension = __commonJS({ + "node_modules/ws/lib/extension.js"(exports, module) { + "use strict"; + var { tokenChars } = require_validation(); + function push(dest, name, elem) { + if (dest[name] === void 0) dest[name] = [elem]; + else dest[name].push(elem); + } + function parse4(header) { + const offers = /* @__PURE__ */ Object.create(null); + let params = /* @__PURE__ */ Object.create(null); + let mustUnescape = false; + let isEscaping = false; + let inQuotes = false; + let extensionName; + let paramName; + let start = -1; + let code = -1; + let end = -1; + let i = 0; + for (; i < header.length; i++) { + code = header.charCodeAt(i); + if (extensionName === void 0) { + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (i !== 0 && (code === 32 || code === 9)) { + if (end === -1 && start !== -1) end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + const name = header.slice(start, end); + if (code === 44) { + push(offers, name, params); + params = /* @__PURE__ */ Object.create(null); + } else { + extensionName = name; + } + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else if (paramName === void 0) { + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (code === 32 || code === 9) { + if (end === -1 && start !== -1) end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + push(params, header.slice(start, end), true); + if (code === 44) { + push(offers, extensionName, params); + params = /* @__PURE__ */ Object.create(null); + extensionName = void 0; + } + start = end = -1; + } else if (code === 61 && start !== -1 && end === -1) { + paramName = header.slice(start, i); + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else { + if (isEscaping) { + if (tokenChars[code] !== 1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (start === -1) start = i; + else if (!mustUnescape) mustUnescape = true; + isEscaping = false; + } else if (inQuotes) { + if (tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (code === 34 && start !== -1) { + inQuotes = false; + end = i; + } else if (code === 92) { + isEscaping = true; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } else if (code === 34 && header.charCodeAt(i - 1) === 61) { + inQuotes = true; + } else if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (start !== -1 && (code === 32 || code === 9)) { + if (end === -1) end = i; + } else if (code === 59 || code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + let value = header.slice(start, end); + if (mustUnescape) { + value = value.replace(/\\/g, ""); + mustUnescape = false; + } + push(params, paramName, value); + if (code === 44) { + push(offers, extensionName, params); + params = /* @__PURE__ */ Object.create(null); + extensionName = void 0; + } + paramName = void 0; + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } + } + if (start === -1 || inQuotes || code === 32 || code === 9) { + throw new SyntaxError("Unexpected end of input"); + } + if (end === -1) end = i; + const token = header.slice(start, end); + if (extensionName === void 0) { + push(offers, token, params); + } else { + if (paramName === void 0) { + push(params, token, true); + } else if (mustUnescape) { + push(params, paramName, token.replace(/\\/g, "")); + } else { + push(params, paramName, token); + } + push(offers, extensionName, params); + } + return offers; + } + function format(extensions) { + return Object.keys(extensions).map((extension) => { + let configurations = extensions[extension]; + if (!Array.isArray(configurations)) configurations = [configurations]; + return configurations.map((params) => { + return [extension].concat( + Object.keys(params).map((k) => { + let values = params[k]; + if (!Array.isArray(values)) values = [values]; + return values.map((v) => v === true ? k : `${k}=${v}`).join("; "); + }) + ).join("; "); + }).join(", "); + }).join(", "); + } + module.exports = { format, parse: parse4 }; + } +}); + +// node_modules/ws/lib/websocket.js +var require_websocket = __commonJS({ + "node_modules/ws/lib/websocket.js"(exports, module) { + "use strict"; + var EventEmitter = __require("events"); + var https = __require("https"); + var http = __require("http"); + var net = __require("net"); + var tls = __require("tls"); + var { randomBytes: randomBytes2, createHash } = __require("crypto"); + var { Duplex, Readable } = __require("stream"); + var { URL: URL2 } = __require("url"); + var PerMessageDeflate = require_permessage_deflate(); + var Receiver2 = require_receiver(); + var Sender2 = require_sender(); + var { isBlob } = require_validation(); + var { + BINARY_TYPES, + CLOSE_TIMEOUT, + EMPTY_BUFFER, + GUID, + kForOnEventAttribute, + kListener, + kStatusCode, + kWebSocket, + NOOP + } = require_constants(); + var { + EventTarget: { addEventListener, removeEventListener } + } = require_event_target(); + var { format, parse: parse4 } = require_extension(); + var { toBuffer } = require_buffer_util(); + var kAborted = Symbol("kAborted"); + var protocolVersions = [8, 13]; + var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"]; + var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/; + var WebSocket2 = class _WebSocket extends EventEmitter { + /** + * Create a new `WebSocket`. + * + * @param {(String|URL)} address The URL to which to connect + * @param {(String|String[])} [protocols] The subprotocols + * @param {Object} [options] Connection options + */ + constructor(address, protocols, options) { + super(); + this._binaryType = BINARY_TYPES[0]; + this._closeCode = 1006; + this._closeFrameReceived = false; + this._closeFrameSent = false; + this._closeMessage = EMPTY_BUFFER; + this._closeTimer = null; + this._errorEmitted = false; + this._extensions = {}; + this._paused = false; + this._protocol = ""; + this._readyState = _WebSocket.CONNECTING; + this._receiver = null; + this._sender = null; + this._socket = null; + if (address !== null) { + this._bufferedAmount = 0; + this._isServer = false; + this._redirects = 0; + if (protocols === void 0) { + protocols = []; + } else if (!Array.isArray(protocols)) { + if (typeof protocols === "object" && protocols !== null) { + options = protocols; + protocols = []; + } else { + protocols = [protocols]; + } + } + initAsClient(this, address, protocols, options); + } else { + this._autoPong = options.autoPong; + this._closeTimeout = options.closeTimeout; + this._isServer = true; + } + } + /** + * For historical reasons, the custom "nodebuffer" type is used by the default + * instead of "blob". + * + * @type {String} + */ + get binaryType() { + return this._binaryType; + } + set binaryType(type) { + if (!BINARY_TYPES.includes(type)) return; + this._binaryType = type; + if (this._receiver) this._receiver._binaryType = type; + } + /** + * @type {Number} + */ + get bufferedAmount() { + if (!this._socket) return this._bufferedAmount; + return this._socket._writableState.length + this._sender._bufferedBytes; + } + /** + * @type {String} + */ + get extensions() { + return Object.keys(this._extensions).join(); + } + /** + * @type {Boolean} + */ + get isPaused() { + return this._paused; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onclose() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onerror() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onopen() { + return null; + } + /** + * @type {Function} + */ + /* istanbul ignore next */ + get onmessage() { + return null; + } + /** + * @type {String} + */ + get protocol() { + return this._protocol; + } + /** + * @type {Number} + */ + get readyState() { + return this._readyState; + } + /** + * @type {String} + */ + get url() { + return this._url; + } + /** + * Set up the socket and the internal resources. + * + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Object} options Options object + * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {Function} [options.generateMask] The function used to generate the + * masking key + * @param {Number} [options.maxPayload=0] The maximum allowed message size + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + * @private + */ + setSocket(socket, head, options) { + const receiver = new Receiver2({ + allowSynchronousEvents: options.allowSynchronousEvents, + binaryType: this.binaryType, + extensions: this._extensions, + isServer: this._isServer, + maxPayload: options.maxPayload, + skipUTF8Validation: options.skipUTF8Validation + }); + const sender = new Sender2(socket, this._extensions, options.generateMask); + this._receiver = receiver; + this._sender = sender; + this._socket = socket; + receiver[kWebSocket] = this; + sender[kWebSocket] = this; + socket[kWebSocket] = this; + receiver.on("conclude", receiverOnConclude); + receiver.on("drain", receiverOnDrain); + receiver.on("error", receiverOnError); + receiver.on("message", receiverOnMessage); + receiver.on("ping", receiverOnPing); + receiver.on("pong", receiverOnPong); + sender.onerror = senderOnError; + if (socket.setTimeout) socket.setTimeout(0); + if (socket.setNoDelay) socket.setNoDelay(); + if (head.length > 0) socket.unshift(head); + socket.on("close", socketOnClose); + socket.on("data", socketOnData); + socket.on("end", socketOnEnd); + socket.on("error", socketOnError); + this._readyState = _WebSocket.OPEN; + this.emit("open"); + } + /** + * Emit the `'close'` event. + * + * @private + */ + emitClose() { + if (!this._socket) { + this._readyState = _WebSocket.CLOSED; + this.emit("close", this._closeCode, this._closeMessage); + return; + } + if (this._extensions[PerMessageDeflate.extensionName]) { + this._extensions[PerMessageDeflate.extensionName].cleanup(); + } + this._receiver.removeAllListeners(); + this._readyState = _WebSocket.CLOSED; + this.emit("close", this._closeCode, this._closeMessage); + } + /** + * Start a closing handshake. + * + * +----------+ +-----------+ +----------+ + * - - -|ws.close()|-->|close frame|-->|ws.close()|- - - + * | +----------+ +-----------+ +----------+ | + * +----------+ +-----------+ | + * CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING + * +----------+ +-----------+ | + * | | | +---+ | + * +------------------------+-->|fin| - - - - + * | +---+ | +---+ + * - - - - -|fin|<---------------------+ + * +---+ + * + * @param {Number} [code] Status code explaining why the connection is closing + * @param {(String|Buffer)} [data] The reason why the connection is + * closing + * @public + */ + close(code, data) { + if (this.readyState === _WebSocket.CLOSED) return; + if (this.readyState === _WebSocket.CONNECTING) { + const msg = "WebSocket was closed before the connection was established"; + abortHandshake(this, this._req, msg); + return; + } + if (this.readyState === _WebSocket.CLOSING) { + if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) { + this._socket.end(); + } + return; + } + this._readyState = _WebSocket.CLOSING; + this._sender.close(code, data, !this._isServer, (err) => { + if (err) return; + this._closeFrameSent = true; + if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) { + this._socket.end(); + } + }); + setCloseTimer(this); + } + /** + * Pause the socket. + * + * @public + */ + pause() { + if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) { + return; + } + this._paused = true; + this._socket.pause(); + } + /** + * Send a ping. + * + * @param {*} [data] The data to send + * @param {Boolean} [mask] Indicates whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when the ping is sent + * @public + */ + ping(data, mask, cb) { + if (this.readyState === _WebSocket.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof data === "function") { + cb = data; + data = mask = void 0; + } else if (typeof mask === "function") { + cb = mask; + mask = void 0; + } + if (typeof data === "number") data = data.toString(); + if (this.readyState !== _WebSocket.OPEN) { + sendAfterClose(this, data, cb); + return; + } + if (mask === void 0) mask = !this._isServer; + this._sender.ping(data || EMPTY_BUFFER, mask, cb); + } + /** + * Send a pong. + * + * @param {*} [data] The data to send + * @param {Boolean} [mask] Indicates whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when the pong is sent + * @public + */ + pong(data, mask, cb) { + if (this.readyState === _WebSocket.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof data === "function") { + cb = data; + data = mask = void 0; + } else if (typeof mask === "function") { + cb = mask; + mask = void 0; + } + if (typeof data === "number") data = data.toString(); + if (this.readyState !== _WebSocket.OPEN) { + sendAfterClose(this, data, cb); + return; + } + if (mask === void 0) mask = !this._isServer; + this._sender.pong(data || EMPTY_BUFFER, mask, cb); + } + /** + * Resume the socket. + * + * @public + */ + resume() { + if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) { + return; + } + this._paused = false; + if (!this._receiver._writableState.needDrain) this._socket.resume(); + } + /** + * Send a data message. + * + * @param {*} data The message to send + * @param {Object} [options] Options object + * @param {Boolean} [options.binary] Specifies whether `data` is binary or + * text + * @param {Boolean} [options.compress] Specifies whether or not to compress + * `data` + * @param {Boolean} [options.fin=true] Specifies whether the fragment is the + * last one + * @param {Boolean} [options.mask] Specifies whether or not to mask `data` + * @param {Function} [cb] Callback which is executed when data is written out + * @public + */ + send(data, options, cb) { + if (this.readyState === _WebSocket.CONNECTING) { + throw new Error("WebSocket is not open: readyState 0 (CONNECTING)"); + } + if (typeof options === "function") { + cb = options; + options = {}; + } + if (typeof data === "number") data = data.toString(); + if (this.readyState !== _WebSocket.OPEN) { + sendAfterClose(this, data, cb); + return; + } + const opts = { + binary: typeof data !== "string", + mask: !this._isServer, + compress: true, + fin: true, + ...options + }; + if (!this._extensions[PerMessageDeflate.extensionName]) { + opts.compress = false; + } + this._sender.send(data || EMPTY_BUFFER, opts, cb); + } + /** + * Forcibly close the connection. + * + * @public + */ + terminate() { + if (this.readyState === _WebSocket.CLOSED) return; + if (this.readyState === _WebSocket.CONNECTING) { + const msg = "WebSocket was closed before the connection was established"; + abortHandshake(this, this._req, msg); + return; + } + if (this._socket) { + this._readyState = _WebSocket.CLOSING; + this._socket.destroy(); + } + } + }; + Object.defineProperty(WebSocket2, "CONNECTING", { + enumerable: true, + value: readyStates.indexOf("CONNECTING") + }); + Object.defineProperty(WebSocket2.prototype, "CONNECTING", { + enumerable: true, + value: readyStates.indexOf("CONNECTING") + }); + Object.defineProperty(WebSocket2, "OPEN", { + enumerable: true, + value: readyStates.indexOf("OPEN") + }); + Object.defineProperty(WebSocket2.prototype, "OPEN", { + enumerable: true, + value: readyStates.indexOf("OPEN") + }); + Object.defineProperty(WebSocket2, "CLOSING", { + enumerable: true, + value: readyStates.indexOf("CLOSING") + }); + Object.defineProperty(WebSocket2.prototype, "CLOSING", { + enumerable: true, + value: readyStates.indexOf("CLOSING") + }); + Object.defineProperty(WebSocket2, "CLOSED", { + enumerable: true, + value: readyStates.indexOf("CLOSED") + }); + Object.defineProperty(WebSocket2.prototype, "CLOSED", { + enumerable: true, + value: readyStates.indexOf("CLOSED") + }); + [ + "binaryType", + "bufferedAmount", + "extensions", + "isPaused", + "protocol", + "readyState", + "url" + ].forEach((property) => { + Object.defineProperty(WebSocket2.prototype, property, { enumerable: true }); + }); + ["open", "error", "close", "message"].forEach((method) => { + Object.defineProperty(WebSocket2.prototype, `on${method}`, { + enumerable: true, + get() { + for (const listener of this.listeners(method)) { + if (listener[kForOnEventAttribute]) return listener[kListener]; + } + return null; + }, + set(handler) { + for (const listener of this.listeners(method)) { + if (listener[kForOnEventAttribute]) { + this.removeListener(method, listener); + break; + } + } + if (typeof handler !== "function") return; + this.addEventListener(method, handler, { + [kForOnEventAttribute]: true + }); + } + }); + }); + WebSocket2.prototype.addEventListener = addEventListener; + WebSocket2.prototype.removeEventListener = removeEventListener; + module.exports = WebSocket2; + function initAsClient(websocket, address, protocols, options) { + const opts = { + allowSynchronousEvents: true, + autoPong: true, + closeTimeout: CLOSE_TIMEOUT, + protocolVersion: protocolVersions[1], + maxPayload: 100 * 1024 * 1024, + skipUTF8Validation: false, + perMessageDeflate: true, + followRedirects: false, + maxRedirects: 10, + ...options, + socketPath: void 0, + hostname: void 0, + protocol: void 0, + timeout: void 0, + method: "GET", + host: void 0, + path: void 0, + port: void 0 + }; + websocket._autoPong = opts.autoPong; + websocket._closeTimeout = opts.closeTimeout; + if (!protocolVersions.includes(opts.protocolVersion)) { + throw new RangeError( + `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})` + ); + } + let parsedUrl; + if (address instanceof URL2) { + parsedUrl = address; + } else { + try { + parsedUrl = new URL2(address); + } catch (e) { + throw new SyntaxError(`Invalid URL: ${address}`); + } + } + if (parsedUrl.protocol === "http:") { + parsedUrl.protocol = "ws:"; + } else if (parsedUrl.protocol === "https:") { + parsedUrl.protocol = "wss:"; + } + websocket._url = parsedUrl.href; + const isSecure = parsedUrl.protocol === "wss:"; + const isIpcUrl = parsedUrl.protocol === "ws+unix:"; + let invalidUrlMessage; + if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) { + invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`; + } else if (isIpcUrl && !parsedUrl.pathname) { + invalidUrlMessage = "The URL's pathname is empty"; + } else if (parsedUrl.hash) { + invalidUrlMessage = "The URL contains a fragment identifier"; + } + if (invalidUrlMessage) { + const err = new SyntaxError(invalidUrlMessage); + if (websocket._redirects === 0) { + throw err; + } else { + emitErrorAndClose(websocket, err); + return; + } + } + const defaultPort = isSecure ? 443 : 80; + const key = randomBytes2(16).toString("base64"); + const request = isSecure ? https.request : http.request; + const protocolSet = /* @__PURE__ */ new Set(); + let perMessageDeflate; + opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect); + opts.defaultPort = opts.defaultPort || defaultPort; + opts.port = parsedUrl.port || defaultPort; + opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname; + opts.headers = { + ...opts.headers, + "Sec-WebSocket-Version": opts.protocolVersion, + "Sec-WebSocket-Key": key, + Connection: "Upgrade", + Upgrade: "websocket" + }; + opts.path = parsedUrl.pathname + parsedUrl.search; + opts.timeout = opts.handshakeTimeout; + if (opts.perMessageDeflate) { + perMessageDeflate = new PerMessageDeflate( + opts.perMessageDeflate !== true ? opts.perMessageDeflate : {}, + false, + opts.maxPayload + ); + opts.headers["Sec-WebSocket-Extensions"] = format({ + [PerMessageDeflate.extensionName]: perMessageDeflate.offer() + }); + } + if (protocols.length) { + for (const protocol of protocols) { + if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) { + throw new SyntaxError( + "An invalid or duplicated subprotocol was specified" + ); + } + protocolSet.add(protocol); + } + opts.headers["Sec-WebSocket-Protocol"] = protocols.join(","); + } + if (opts.origin) { + if (opts.protocolVersion < 13) { + opts.headers["Sec-WebSocket-Origin"] = opts.origin; + } else { + opts.headers.Origin = opts.origin; + } + } + if (parsedUrl.username || parsedUrl.password) { + opts.auth = `${parsedUrl.username}:${parsedUrl.password}`; + } + if (isIpcUrl) { + const parts = opts.path.split(":"); + opts.socketPath = parts[0]; + opts.path = parts[1]; + } + let req; + if (opts.followRedirects) { + if (websocket._redirects === 0) { + websocket._originalIpc = isIpcUrl; + websocket._originalSecure = isSecure; + websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host; + const headers = options && options.headers; + options = { ...options, headers: {} }; + if (headers) { + for (const [key2, value] of Object.entries(headers)) { + options.headers[key2.toLowerCase()] = value; + } + } + } else if (websocket.listenerCount("redirect") === 0) { + const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath; + if (!isSameHost || websocket._originalSecure && !isSecure) { + delete opts.headers.authorization; + delete opts.headers.cookie; + if (!isSameHost) delete opts.headers.host; + opts.auth = void 0; + } + } + if (opts.auth && !options.headers.authorization) { + options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64"); + } + req = websocket._req = request(opts); + if (websocket._redirects) { + websocket.emit("redirect", websocket.url, req); + } + } else { + req = websocket._req = request(opts); + } + if (opts.timeout) { + req.on("timeout", () => { + abortHandshake(websocket, req, "Opening handshake has timed out"); + }); + } + req.on("error", (err) => { + if (req === null || req[kAborted]) return; + req = websocket._req = null; + emitErrorAndClose(websocket, err); + }); + req.on("response", (res) => { + const location = res.headers.location; + const statusCode = res.statusCode; + if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) { + if (++websocket._redirects > opts.maxRedirects) { + abortHandshake(websocket, req, "Maximum redirects exceeded"); + return; + } + req.abort(); + let addr; + try { + addr = new URL2(location, address); + } catch (e) { + const err = new SyntaxError(`Invalid URL: ${location}`); + emitErrorAndClose(websocket, err); + return; + } + initAsClient(websocket, addr, protocols, options); + } else if (!websocket.emit("unexpected-response", req, res)) { + abortHandshake( + websocket, + req, + `Unexpected server response: ${res.statusCode}` + ); + } + }); + req.on("upgrade", (res, socket, head) => { + websocket.emit("upgrade", res); + if (websocket.readyState !== WebSocket2.CONNECTING) return; + req = websocket._req = null; + const upgrade = res.headers.upgrade; + if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") { + abortHandshake(websocket, socket, "Invalid Upgrade header"); + return; + } + const digest = createHash("sha1").update(key + GUID).digest("base64"); + if (res.headers["sec-websocket-accept"] !== digest) { + abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header"); + return; + } + const serverProt = res.headers["sec-websocket-protocol"]; + let protError; + if (serverProt !== void 0) { + if (!protocolSet.size) { + protError = "Server sent a subprotocol but none was requested"; + } else if (!protocolSet.has(serverProt)) { + protError = "Server sent an invalid subprotocol"; + } + } else if (protocolSet.size) { + protError = "Server sent no subprotocol"; + } + if (protError) { + abortHandshake(websocket, socket, protError); + return; + } + if (serverProt) websocket._protocol = serverProt; + const secWebSocketExtensions = res.headers["sec-websocket-extensions"]; + if (secWebSocketExtensions !== void 0) { + if (!perMessageDeflate) { + const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested"; + abortHandshake(websocket, socket, message); + return; + } + let extensions; + try { + extensions = parse4(secWebSocketExtensions); + } catch (err) { + const message = "Invalid Sec-WebSocket-Extensions header"; + abortHandshake(websocket, socket, message); + return; + } + const extensionNames = Object.keys(extensions); + if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) { + const message = "Server indicated an extension that was not requested"; + abortHandshake(websocket, socket, message); + return; + } + try { + perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]); + } catch (err) { + const message = "Invalid Sec-WebSocket-Extensions header"; + abortHandshake(websocket, socket, message); + return; + } + websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate; + } + websocket.setSocket(socket, head, { + allowSynchronousEvents: opts.allowSynchronousEvents, + generateMask: opts.generateMask, + maxPayload: opts.maxPayload, + skipUTF8Validation: opts.skipUTF8Validation + }); + }); + if (opts.finishRequest) { + opts.finishRequest(req, websocket); + } else { + req.end(); + } + } + function emitErrorAndClose(websocket, err) { + websocket._readyState = WebSocket2.CLOSING; + websocket._errorEmitted = true; + websocket.emit("error", err); + websocket.emitClose(); + } + function netConnect(options) { + options.path = options.socketPath; + return net.connect(options); + } + function tlsConnect(options) { + options.path = void 0; + if (!options.servername && options.servername !== "") { + options.servername = net.isIP(options.host) ? "" : options.host; + } + return tls.connect(options); + } + function abortHandshake(websocket, stream, message) { + websocket._readyState = WebSocket2.CLOSING; + const err = new Error(message); + Error.captureStackTrace(err, abortHandshake); + if (stream.setHeader) { + stream[kAborted] = true; + stream.abort(); + if (stream.socket && !stream.socket.destroyed) { + stream.socket.destroy(); + } + process.nextTick(emitErrorAndClose, websocket, err); + } else { + stream.destroy(err); + stream.once("error", websocket.emit.bind(websocket, "error")); + stream.once("close", websocket.emitClose.bind(websocket)); + } + } + function sendAfterClose(websocket, data, cb) { + if (data) { + const length = isBlob(data) ? data.size : toBuffer(data).length; + if (websocket._socket) websocket._sender._bufferedBytes += length; + else websocket._bufferedAmount += length; + } + if (cb) { + const err = new Error( + `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})` + ); + process.nextTick(cb, err); + } + } + function receiverOnConclude(code, reason) { + const websocket = this[kWebSocket]; + websocket._closeFrameReceived = true; + websocket._closeMessage = reason; + websocket._closeCode = code; + if (websocket._socket[kWebSocket] === void 0) return; + websocket._socket.removeListener("data", socketOnData); + process.nextTick(resume, websocket._socket); + if (code === 1005) websocket.close(); + else websocket.close(code, reason); + } + function receiverOnDrain() { + const websocket = this[kWebSocket]; + if (!websocket.isPaused) websocket._socket.resume(); + } + function receiverOnError(err) { + const websocket = this[kWebSocket]; + if (websocket._socket[kWebSocket] !== void 0) { + websocket._socket.removeListener("data", socketOnData); + process.nextTick(resume, websocket._socket); + websocket.close(err[kStatusCode]); + } + if (!websocket._errorEmitted) { + websocket._errorEmitted = true; + websocket.emit("error", err); + } + } + function receiverOnFinish() { + this[kWebSocket].emitClose(); + } + function receiverOnMessage(data, isBinary) { + this[kWebSocket].emit("message", data, isBinary); + } + function receiverOnPing(data) { + const websocket = this[kWebSocket]; + if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP); + websocket.emit("ping", data); + } + function receiverOnPong(data) { + this[kWebSocket].emit("pong", data); + } + function resume(stream) { + stream.resume(); + } + function senderOnError(err) { + const websocket = this[kWebSocket]; + if (websocket.readyState === WebSocket2.CLOSED) return; + if (websocket.readyState === WebSocket2.OPEN) { + websocket._readyState = WebSocket2.CLOSING; + setCloseTimer(websocket); + } + this._socket.end(); + if (!websocket._errorEmitted) { + websocket._errorEmitted = true; + websocket.emit("error", err); + } + } + function setCloseTimer(websocket) { + websocket._closeTimer = setTimeout( + websocket._socket.destroy.bind(websocket._socket), + websocket._closeTimeout + ); + } + function socketOnClose() { + const websocket = this[kWebSocket]; + this.removeListener("close", socketOnClose); + this.removeListener("data", socketOnData); + this.removeListener("end", socketOnEnd); + websocket._readyState = WebSocket2.CLOSING; + if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) { + const chunk = this.read(this._readableState.length); + websocket._receiver.write(chunk); + } + websocket._receiver.end(); + this[kWebSocket] = void 0; + clearTimeout(websocket._closeTimer); + if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) { + websocket.emitClose(); + } else { + websocket._receiver.on("error", receiverOnFinish); + websocket._receiver.on("finish", receiverOnFinish); + } + } + function socketOnData(chunk) { + if (!this[kWebSocket]._receiver.write(chunk)) { + this.pause(); + } + } + function socketOnEnd() { + const websocket = this[kWebSocket]; + websocket._readyState = WebSocket2.CLOSING; + websocket._receiver.end(); + this.end(); + } + function socketOnError() { + const websocket = this[kWebSocket]; + this.removeListener("error", socketOnError); + this.on("error", NOOP); + if (websocket) { + websocket._readyState = WebSocket2.CLOSING; + this.destroy(); + } + } + } +}); + +// node_modules/ws/lib/stream.js +var require_stream = __commonJS({ + "node_modules/ws/lib/stream.js"(exports, module) { + "use strict"; + var WebSocket2 = require_websocket(); + var { Duplex } = __require("stream"); + function emitClose(stream) { + stream.emit("close"); + } + function duplexOnEnd() { + if (!this.destroyed && this._writableState.finished) { + this.destroy(); + } + } + function duplexOnError(err) { + this.removeListener("error", duplexOnError); + this.destroy(); + if (this.listenerCount("error") === 0) { + this.emit("error", err); + } + } + function createWebSocketStream2(ws, options) { + let terminateOnDestroy = true; + const duplex = new Duplex({ + ...options, + autoDestroy: false, + emitClose: false, + objectMode: false, + writableObjectMode: false + }); + ws.on("message", function message(msg, isBinary) { + const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg; + if (!duplex.push(data)) ws.pause(); + }); + ws.once("error", function error2(err) { + if (duplex.destroyed) return; + terminateOnDestroy = false; + duplex.destroy(err); + }); + ws.once("close", function close() { + if (duplex.destroyed) return; + duplex.push(null); + }); + duplex._destroy = function(err, callback) { + if (ws.readyState === ws.CLOSED) { + callback(err); + process.nextTick(emitClose, duplex); + return; + } + let called = false; + ws.once("error", function error2(err2) { + called = true; + callback(err2); + }); + ws.once("close", function close() { + if (!called) callback(err); + process.nextTick(emitClose, duplex); + }); + if (terminateOnDestroy) ws.terminate(); + }; + duplex._final = function(callback) { + if (ws.readyState === ws.CONNECTING) { + ws.once("open", function open() { + duplex._final(callback); + }); + return; + } + if (ws._socket === null) return; + if (ws._socket._writableState.finished) { + callback(); + if (duplex._readableState.endEmitted) duplex.destroy(); + } else { + ws._socket.once("finish", function finish() { + callback(); + }); + ws.close(); + } + }; + duplex._read = function() { + if (ws.isPaused) ws.resume(); + }; + duplex._write = function(chunk, encoding, callback) { + if (ws.readyState === ws.CONNECTING) { + ws.once("open", function open() { + duplex._write(chunk, encoding, callback); + }); + return; + } + ws.send(chunk, callback); + }; + duplex.on("end", duplexOnEnd); + duplex.on("error", duplexOnError); + return duplex; + } + module.exports = createWebSocketStream2; + } +}); + +// node_modules/ws/lib/subprotocol.js +var require_subprotocol = __commonJS({ + "node_modules/ws/lib/subprotocol.js"(exports, module) { + "use strict"; + var { tokenChars } = require_validation(); + function parse4(header) { + const protocols = /* @__PURE__ */ new Set(); + let start = -1; + let end = -1; + let i = 0; + for (i; i < header.length; i++) { + const code = header.charCodeAt(i); + if (end === -1 && tokenChars[code] === 1) { + if (start === -1) start = i; + } else if (i !== 0 && (code === 32 || code === 9)) { + if (end === -1 && start !== -1) end = i; + } else if (code === 44) { + if (start === -1) { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + if (end === -1) end = i; + const protocol2 = header.slice(start, end); + if (protocols.has(protocol2)) { + throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`); + } + protocols.add(protocol2); + start = end = -1; + } else { + throw new SyntaxError(`Unexpected character at index ${i}`); + } + } + if (start === -1 || end !== -1) { + throw new SyntaxError("Unexpected end of input"); + } + const protocol = header.slice(start, i); + if (protocols.has(protocol)) { + throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`); + } + protocols.add(protocol); + return protocols; + } + module.exports = { parse: parse4 }; + } +}); + +// node_modules/ws/lib/websocket-server.js +var require_websocket_server = __commonJS({ + "node_modules/ws/lib/websocket-server.js"(exports, module) { + "use strict"; + var EventEmitter = __require("events"); + var http = __require("http"); + var { Duplex } = __require("stream"); + var { createHash } = __require("crypto"); + var extension = require_extension(); + var PerMessageDeflate = require_permessage_deflate(); + var subprotocol = require_subprotocol(); + var WebSocket2 = require_websocket(); + var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants(); + var keyRegex = /^[+/0-9A-Za-z]{22}==$/; + var RUNNING = 0; + var CLOSING = 1; + var CLOSED = 2; + var WebSocketServer2 = class extends EventEmitter { + /** + * Create a `WebSocketServer` instance. + * + * @param {Object} options Configuration options + * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether + * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted + * multiple times in the same tick + * @param {Boolean} [options.autoPong=true] Specifies whether or not to + * automatically send a pong in response to a ping + * @param {Number} [options.backlog=511] The maximum length of the queue of + * pending connections + * @param {Boolean} [options.clientTracking=true] Specifies whether or not to + * track clients + * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to + * wait for the closing handshake to finish after `websocket.close()` is + * called + * @param {Function} [options.handleProtocols] A hook to handle protocols + * @param {String} [options.host] The hostname where to bind the server + * @param {Number} [options.maxPayload=104857600] The maximum allowed message + * size + * @param {Boolean} [options.noServer=false] Enable no server mode + * @param {String} [options.path] Accept only connections matching this path + * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable + * permessage-deflate + * @param {Number} [options.port] The port where to bind the server + * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S + * server to use + * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or + * not to skip UTF-8 validation for text and close messages + * @param {Function} [options.verifyClient] A hook to reject connections + * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket` + * class to use. It must be the `WebSocket` class or class that extends it + * @param {Function} [callback] A listener for the `listening` event + */ + constructor(options, callback) { + super(); + options = { + allowSynchronousEvents: true, + autoPong: true, + maxPayload: 100 * 1024 * 1024, + skipUTF8Validation: false, + perMessageDeflate: false, + handleProtocols: null, + clientTracking: true, + closeTimeout: CLOSE_TIMEOUT, + verifyClient: null, + noServer: false, + backlog: null, + // use default (511 as implemented in net.js) + server: null, + host: null, + path: null, + port: null, + WebSocket: WebSocket2, + ...options + }; + if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) { + throw new TypeError( + 'One and only one of the "port", "server", or "noServer" options must be specified' + ); + } + if (options.port != null) { + this._server = http.createServer((req, res) => { + const body = http.STATUS_CODES[426]; + res.writeHead(426, { + "Content-Length": body.length, + "Content-Type": "text/plain" + }); + res.end(body); + }); + this._server.listen( + options.port, + options.host, + options.backlog, + callback + ); + } else if (options.server) { + this._server = options.server; + } + if (this._server) { + const emitConnection = this.emit.bind(this, "connection"); + this._removeListeners = addListeners(this._server, { + listening: this.emit.bind(this, "listening"), + error: this.emit.bind(this, "error"), + upgrade: (req, socket, head) => { + this.handleUpgrade(req, socket, head, emitConnection); + } + }); + } + if (options.perMessageDeflate === true) options.perMessageDeflate = {}; + if (options.clientTracking) { + this.clients = /* @__PURE__ */ new Set(); + this._shouldEmitClose = false; + } + this.options = options; + this._state = RUNNING; + } + /** + * Returns the bound address, the address family name, and port of the server + * as reported by the operating system if listening on an IP socket. + * If the server is listening on a pipe or UNIX domain socket, the name is + * returned as a string. + * + * @return {(Object|String|null)} The address of the server + * @public + */ + address() { + if (this.options.noServer) { + throw new Error('The server is operating in "noServer" mode'); + } + if (!this._server) return null; + return this._server.address(); + } + /** + * Stop the server from accepting new connections and emit the `'close'` event + * when all existing connections are closed. + * + * @param {Function} [cb] A one-time listener for the `'close'` event + * @public + */ + close(cb) { + if (this._state === CLOSED) { + if (cb) { + this.once("close", () => { + cb(new Error("The server is not running")); + }); + } + process.nextTick(emitClose, this); + return; + } + if (cb) this.once("close", cb); + if (this._state === CLOSING) return; + this._state = CLOSING; + if (this.options.noServer || this.options.server) { + if (this._server) { + this._removeListeners(); + this._removeListeners = this._server = null; + } + if (this.clients) { + if (!this.clients.size) { + process.nextTick(emitClose, this); + } else { + this._shouldEmitClose = true; + } + } else { + process.nextTick(emitClose, this); + } + } else { + const server = this._server; + this._removeListeners(); + this._removeListeners = this._server = null; + server.close(() => { + emitClose(this); + }); + } + } + /** + * See if a given request should be handled by this server instance. + * + * @param {http.IncomingMessage} req Request object to inspect + * @return {Boolean} `true` if the request is valid, else `false` + * @public + */ + shouldHandle(req) { + if (this.options.path) { + const index = req.url.indexOf("?"); + const pathname = index !== -1 ? req.url.slice(0, index) : req.url; + if (pathname !== this.options.path) return false; + } + return true; + } + /** + * Handle a HTTP Upgrade request. + * + * @param {http.IncomingMessage} req The request object + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Function} cb Callback + * @public + */ + handleUpgrade(req, socket, head, cb) { + socket.on("error", socketOnError); + const key = req.headers["sec-websocket-key"]; + const upgrade = req.headers.upgrade; + const version2 = +req.headers["sec-websocket-version"]; + if (req.method !== "GET") { + const message = "Invalid HTTP method"; + abortHandshakeOrEmitwsClientError(this, req, socket, 405, message); + return; + } + if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") { + const message = "Invalid Upgrade header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + if (key === void 0 || !keyRegex.test(key)) { + const message = "Missing or invalid Sec-WebSocket-Key header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + if (version2 !== 13 && version2 !== 8) { + const message = "Missing or invalid Sec-WebSocket-Version header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, { + "Sec-WebSocket-Version": "13, 8" + }); + return; + } + if (!this.shouldHandle(req)) { + abortHandshake(socket, 400); + return; + } + const secWebSocketProtocol = req.headers["sec-websocket-protocol"]; + let protocols = /* @__PURE__ */ new Set(); + if (secWebSocketProtocol !== void 0) { + try { + protocols = subprotocol.parse(secWebSocketProtocol); + } catch (err) { + const message = "Invalid Sec-WebSocket-Protocol header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + } + const secWebSocketExtensions = req.headers["sec-websocket-extensions"]; + const extensions = {}; + if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) { + const perMessageDeflate = new PerMessageDeflate( + this.options.perMessageDeflate, + true, + this.options.maxPayload + ); + try { + const offers = extension.parse(secWebSocketExtensions); + if (offers[PerMessageDeflate.extensionName]) { + perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]); + extensions[PerMessageDeflate.extensionName] = perMessageDeflate; + } + } catch (err) { + const message = "Invalid or unacceptable Sec-WebSocket-Extensions header"; + abortHandshakeOrEmitwsClientError(this, req, socket, 400, message); + return; + } + } + if (this.options.verifyClient) { + const info = { + origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`], + secure: !!(req.socket.authorized || req.socket.encrypted), + req + }; + if (this.options.verifyClient.length === 2) { + this.options.verifyClient(info, (verified, code, message, headers) => { + if (!verified) { + return abortHandshake(socket, code || 401, message, headers); + } + this.completeUpgrade( + extensions, + key, + protocols, + req, + socket, + head, + cb + ); + }); + return; + } + if (!this.options.verifyClient(info)) return abortHandshake(socket, 401); + } + this.completeUpgrade(extensions, key, protocols, req, socket, head, cb); + } + /** + * Upgrade the connection to WebSocket. + * + * @param {Object} extensions The accepted extensions + * @param {String} key The value of the `Sec-WebSocket-Key` header + * @param {Set} protocols The subprotocols + * @param {http.IncomingMessage} req The request object + * @param {Duplex} socket The network socket between the server and client + * @param {Buffer} head The first packet of the upgraded stream + * @param {Function} cb Callback + * @throws {Error} If called more than once with the same socket + * @private + */ + completeUpgrade(extensions, key, protocols, req, socket, head, cb) { + if (!socket.readable || !socket.writable) return socket.destroy(); + if (socket[kWebSocket]) { + throw new Error( + "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration" + ); + } + if (this._state > RUNNING) return abortHandshake(socket, 503); + const digest = createHash("sha1").update(key + GUID).digest("base64"); + const headers = [ + "HTTP/1.1 101 Switching Protocols", + "Upgrade: websocket", + "Connection: Upgrade", + `Sec-WebSocket-Accept: ${digest}` + ]; + const ws = new this.options.WebSocket(null, void 0, this.options); + if (protocols.size) { + const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value; + if (protocol) { + headers.push(`Sec-WebSocket-Protocol: ${protocol}`); + ws._protocol = protocol; + } + } + if (extensions[PerMessageDeflate.extensionName]) { + const params = extensions[PerMessageDeflate.extensionName].params; + const value = extension.format({ + [PerMessageDeflate.extensionName]: [params] + }); + headers.push(`Sec-WebSocket-Extensions: ${value}`); + ws._extensions = extensions; + } + this.emit("headers", headers, req); + socket.write(headers.concat("\r\n").join("\r\n")); + socket.removeListener("error", socketOnError); + ws.setSocket(socket, head, { + allowSynchronousEvents: this.options.allowSynchronousEvents, + maxPayload: this.options.maxPayload, + skipUTF8Validation: this.options.skipUTF8Validation + }); + if (this.clients) { + this.clients.add(ws); + ws.on("close", () => { + this.clients.delete(ws); + if (this._shouldEmitClose && !this.clients.size) { + process.nextTick(emitClose, this); + } + }); + } + cb(ws, req); + } + }; + module.exports = WebSocketServer2; + function addListeners(server, map2) { + for (const event of Object.keys(map2)) server.on(event, map2[event]); + return function removeListeners() { + for (const event of Object.keys(map2)) { + server.removeListener(event, map2[event]); + } + }; + } + function emitClose(server) { + server._state = CLOSED; + server.emit("close"); + } + function socketOnError() { + this.destroy(); + } + function abortHandshake(socket, code, message, headers) { + message = message || http.STATUS_CODES[code]; + headers = { + Connection: "close", + "Content-Type": "text/html", + "Content-Length": Buffer.byteLength(message), + ...headers + }; + socket.once("finish", socket.destroy); + socket.end( + `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r +` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message + ); + } + function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) { + if (server.listenerCount("wsClientError")) { + const err = new Error(message); + Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError); + server.emit("wsClientError", err, socket, req); + } else { + abortHandshake(socket, code, message, headers); + } + } + } +}); + +// node_modules/ajv/dist/compile/codegen/code.js +var require_code = __commonJS({ + "node_modules/ajv/dist/compile/codegen/code.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.regexpCode = exports.getEsmExportName = exports.getProperty = exports.safeStringify = exports.stringify = exports.strConcat = exports.addCodeArg = exports.str = exports._ = exports.nil = exports._Code = exports.Name = exports.IDENTIFIER = exports._CodeOrName = void 0; + var _CodeOrName = class { + }; + exports._CodeOrName = _CodeOrName; + exports.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; + var Name = class extends _CodeOrName { + constructor(s) { + super(); + if (!exports.IDENTIFIER.test(s)) + throw new Error("CodeGen: name must be a valid identifier"); + this.str = s; + } + toString() { + return this.str; + } + emptyStr() { + return false; + } + get names() { + return { [this.str]: 1 }; + } + }; + exports.Name = Name; + var _Code = class extends _CodeOrName { + constructor(code) { + super(); + this._items = typeof code === "string" ? [code] : code; + } + toString() { + return this.str; + } + emptyStr() { + if (this._items.length > 1) + return false; + const item = this._items[0]; + return item === "" || item === '""'; + } + get str() { + var _a2; + return (_a2 = this._str) !== null && _a2 !== void 0 ? _a2 : this._str = this._items.reduce((s, c) => `${s}${c}`, ""); + } + get names() { + var _a2; + return (_a2 = this._names) !== null && _a2 !== void 0 ? _a2 : this._names = this._items.reduce((names, c) => { + if (c instanceof Name) + names[c.str] = (names[c.str] || 0) + 1; + return names; + }, {}); + } + }; + exports._Code = _Code; + exports.nil = new _Code(""); + function _(strs, ...args) { + const code = [strs[0]]; + let i = 0; + while (i < args.length) { + addCodeArg(code, args[i]); + code.push(strs[++i]); + } + return new _Code(code); + } + exports._ = _; + var plus = new _Code("+"); + function str(strs, ...args) { + const expr = [safeStringify(strs[0])]; + let i = 0; + while (i < args.length) { + expr.push(plus); + addCodeArg(expr, args[i]); + expr.push(plus, safeStringify(strs[++i])); + } + optimize(expr); + return new _Code(expr); + } + exports.str = str; + function addCodeArg(code, arg) { + if (arg instanceof _Code) + code.push(...arg._items); + else if (arg instanceof Name) + code.push(arg); + else + code.push(interpolate(arg)); + } + exports.addCodeArg = addCodeArg; + function optimize(expr) { + let i = 1; + while (i < expr.length - 1) { + if (expr[i] === plus) { + const res = mergeExprItems(expr[i - 1], expr[i + 1]); + if (res !== void 0) { + expr.splice(i - 1, 3, res); + continue; + } + expr[i++] = "+"; + } + i++; + } + } + function mergeExprItems(a, b) { + if (b === '""') + return a; + if (a === '""') + return b; + if (typeof a == "string") { + if (b instanceof Name || a[a.length - 1] !== '"') + return; + if (typeof b != "string") + return `${a.slice(0, -1)}${b}"`; + if (b[0] === '"') + return a.slice(0, -1) + b.slice(1); + return; + } + if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) + return `"${a}${b.slice(1)}`; + return; + } + function strConcat(c1, c2) { + return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`; + } + exports.strConcat = strConcat; + function interpolate(x) { + return typeof x == "number" || typeof x == "boolean" || x === null ? x : safeStringify(Array.isArray(x) ? x.join(",") : x); + } + function stringify(x) { + return new _Code(safeStringify(x)); + } + exports.stringify = stringify; + function safeStringify(x) { + return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029"); + } + exports.safeStringify = safeStringify; + function getProperty(key) { + return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`; + } + exports.getProperty = getProperty; + function getEsmExportName(key) { + if (typeof key == "string" && exports.IDENTIFIER.test(key)) { + return new _Code(`${key}`); + } + throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`); + } + exports.getEsmExportName = getEsmExportName; + function regexpCode(rx) { + return new _Code(rx.toString()); + } + exports.regexpCode = regexpCode; + } +}); + +// node_modules/ajv/dist/compile/codegen/scope.js +var require_scope = __commonJS({ + "node_modules/ajv/dist/compile/codegen/scope.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0; + var code_1 = require_code(); + var ValueError = class extends Error { + constructor(name) { + super(`CodeGen: "code" for ${name} not defined`); + this.value = name.value; + } + }; + var UsedValueState; + (function(UsedValueState2) { + UsedValueState2[UsedValueState2["Started"] = 0] = "Started"; + UsedValueState2[UsedValueState2["Completed"] = 1] = "Completed"; + })(UsedValueState || (exports.UsedValueState = UsedValueState = {})); + exports.varKinds = { + const: new code_1.Name("const"), + let: new code_1.Name("let"), + var: new code_1.Name("var") + }; + var Scope = class { + constructor({ prefixes, parent } = {}) { + this._names = {}; + this._prefixes = prefixes; + this._parent = parent; + } + toName(nameOrPrefix) { + return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix); + } + name(prefix) { + return new code_1.Name(this._newName(prefix)); + } + _newName(prefix) { + const ng = this._names[prefix] || this._nameGroup(prefix); + return `${prefix}${ng.index++}`; + } + _nameGroup(prefix) { + var _a2, _b; + if (((_b = (_a2 = this._parent) === null || _a2 === void 0 ? void 0 : _a2._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) { + throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`); + } + return this._names[prefix] = { prefix, index: 0 }; + } + }; + exports.Scope = Scope; + var ValueScopeName = class extends code_1.Name { + constructor(prefix, nameStr) { + super(nameStr); + this.prefix = prefix; + } + setValue(value, { property, itemIndex }) { + this.value = value; + this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`; + } + }; + exports.ValueScopeName = ValueScopeName; + var line = (0, code_1._)`\n`; + var ValueScope = class extends Scope { + constructor(opts) { + super(opts); + this._values = {}; + this._scope = opts.scope; + this.opts = { ...opts, _n: opts.lines ? line : code_1.nil }; + } + get() { + return this._scope; + } + name(prefix) { + return new ValueScopeName(prefix, this._newName(prefix)); + } + value(nameOrPrefix, value) { + var _a2; + if (value.ref === void 0) + throw new Error("CodeGen: ref must be passed in value"); + const name = this.toName(nameOrPrefix); + const { prefix } = name; + const valueKey = (_a2 = value.key) !== null && _a2 !== void 0 ? _a2 : value.ref; + let vs = this._values[prefix]; + if (vs) { + const _name = vs.get(valueKey); + if (_name) + return _name; + } else { + vs = this._values[prefix] = /* @__PURE__ */ new Map(); + } + vs.set(valueKey, name); + const s = this._scope[prefix] || (this._scope[prefix] = []); + const itemIndex = s.length; + s[itemIndex] = value.ref; + name.setValue(value, { property: prefix, itemIndex }); + return name; + } + getValue(prefix, keyOrRef) { + const vs = this._values[prefix]; + if (!vs) + return; + return vs.get(keyOrRef); + } + scopeRefs(scopeName, values = this._values) { + return this._reduceValues(values, (name) => { + if (name.scopePath === void 0) + throw new Error(`CodeGen: name "${name}" has no value`); + return (0, code_1._)`${scopeName}${name.scopePath}`; + }); + } + scopeCode(values = this._values, usedValues, getCode) { + return this._reduceValues(values, (name) => { + if (name.value === void 0) + throw new Error(`CodeGen: name "${name}" has no value`); + return name.value.code; + }, usedValues, getCode); + } + _reduceValues(values, valueCode, usedValues = {}, getCode) { + let code = code_1.nil; + for (const prefix in values) { + const vs = values[prefix]; + if (!vs) + continue; + const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map(); + vs.forEach((name) => { + if (nameSet.has(name)) + return; + nameSet.set(name, UsedValueState.Started); + let c = valueCode(name); + if (c) { + const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const; + code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`; + } else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) { + code = (0, code_1._)`${code}${c}${this.opts._n}`; + } else { + throw new ValueError(name); + } + nameSet.set(name, UsedValueState.Completed); + }); + } + return code; + } + }; + exports.ValueScope = ValueScope; + } +}); + +// node_modules/ajv/dist/compile/codegen/index.js +var require_codegen = __commonJS({ + "node_modules/ajv/dist/compile/codegen/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0; + var code_1 = require_code(); + var scope_1 = require_scope(); + var code_2 = require_code(); + Object.defineProperty(exports, "_", { enumerable: true, get: function() { + return code_2._; + } }); + Object.defineProperty(exports, "str", { enumerable: true, get: function() { + return code_2.str; + } }); + Object.defineProperty(exports, "strConcat", { enumerable: true, get: function() { + return code_2.strConcat; + } }); + Object.defineProperty(exports, "nil", { enumerable: true, get: function() { + return code_2.nil; + } }); + Object.defineProperty(exports, "getProperty", { enumerable: true, get: function() { + return code_2.getProperty; + } }); + Object.defineProperty(exports, "stringify", { enumerable: true, get: function() { + return code_2.stringify; + } }); + Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function() { + return code_2.regexpCode; + } }); + Object.defineProperty(exports, "Name", { enumerable: true, get: function() { + return code_2.Name; + } }); + var scope_2 = require_scope(); + Object.defineProperty(exports, "Scope", { enumerable: true, get: function() { + return scope_2.Scope; + } }); + Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function() { + return scope_2.ValueScope; + } }); + Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function() { + return scope_2.ValueScopeName; + } }); + Object.defineProperty(exports, "varKinds", { enumerable: true, get: function() { + return scope_2.varKinds; + } }); + exports.operators = { + GT: new code_1._Code(">"), + GTE: new code_1._Code(">="), + LT: new code_1._Code("<"), + LTE: new code_1._Code("<="), + EQ: new code_1._Code("==="), + NEQ: new code_1._Code("!=="), + NOT: new code_1._Code("!"), + OR: new code_1._Code("||"), + AND: new code_1._Code("&&"), + ADD: new code_1._Code("+") + }; + var Node = class { + optimizeNodes() { + return this; + } + optimizeNames(_names, _constants) { + return this; + } + }; + var Def = class extends Node { + constructor(varKind, name, rhs) { + super(); + this.varKind = varKind; + this.name = name; + this.rhs = rhs; + } + render({ es5, _n }) { + const varKind = es5 ? scope_1.varKinds.var : this.varKind; + const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`; + return `${varKind} ${this.name}${rhs};` + _n; + } + optimizeNames(names, constants) { + if (!names[this.name.str]) + return; + if (this.rhs) + this.rhs = optimizeExpr(this.rhs, names, constants); + return this; + } + get names() { + return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {}; + } + }; + var Assign = class extends Node { + constructor(lhs, rhs, sideEffects) { + super(); + this.lhs = lhs; + this.rhs = rhs; + this.sideEffects = sideEffects; + } + render({ _n }) { + return `${this.lhs} = ${this.rhs};` + _n; + } + optimizeNames(names, constants) { + if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) + return; + this.rhs = optimizeExpr(this.rhs, names, constants); + return this; + } + get names() { + const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names }; + return addExprNames(names, this.rhs); + } + }; + var AssignOp = class extends Assign { + constructor(lhs, op, rhs, sideEffects) { + super(lhs, rhs, sideEffects); + this.op = op; + } + render({ _n }) { + return `${this.lhs} ${this.op}= ${this.rhs};` + _n; + } + }; + var Label = class extends Node { + constructor(label) { + super(); + this.label = label; + this.names = {}; + } + render({ _n }) { + return `${this.label}:` + _n; + } + }; + var Break = class extends Node { + constructor(label) { + super(); + this.label = label; + this.names = {}; + } + render({ _n }) { + const label = this.label ? ` ${this.label}` : ""; + return `break${label};` + _n; + } + }; + var Throw = class extends Node { + constructor(error2) { + super(); + this.error = error2; + } + render({ _n }) { + return `throw ${this.error};` + _n; + } + get names() { + return this.error.names; + } + }; + var AnyCode = class extends Node { + constructor(code) { + super(); + this.code = code; + } + render({ _n }) { + return `${this.code};` + _n; + } + optimizeNodes() { + return `${this.code}` ? this : void 0; + } + optimizeNames(names, constants) { + this.code = optimizeExpr(this.code, names, constants); + return this; + } + get names() { + return this.code instanceof code_1._CodeOrName ? this.code.names : {}; + } + }; + var ParentNode = class extends Node { + constructor(nodes = []) { + super(); + this.nodes = nodes; + } + render(opts) { + return this.nodes.reduce((code, n) => code + n.render(opts), ""); + } + optimizeNodes() { + const { nodes } = this; + let i = nodes.length; + while (i--) { + const n = nodes[i].optimizeNodes(); + if (Array.isArray(n)) + nodes.splice(i, 1, ...n); + else if (n) + nodes[i] = n; + else + nodes.splice(i, 1); + } + return nodes.length > 0 ? this : void 0; + } + optimizeNames(names, constants) { + const { nodes } = this; + let i = nodes.length; + while (i--) { + const n = nodes[i]; + if (n.optimizeNames(names, constants)) + continue; + subtractNames(names, n.names); + nodes.splice(i, 1); + } + return nodes.length > 0 ? this : void 0; + } + get names() { + return this.nodes.reduce((names, n) => addNames(names, n.names), {}); + } + }; + var BlockNode = class extends ParentNode { + render(opts) { + return "{" + opts._n + super.render(opts) + "}" + opts._n; + } + }; + var Root = class extends ParentNode { + }; + var Else = class extends BlockNode { + }; + Else.kind = "else"; + var If = class _If extends BlockNode { + constructor(condition, nodes) { + super(nodes); + this.condition = condition; + } + render(opts) { + let code = `if(${this.condition})` + super.render(opts); + if (this.else) + code += "else " + this.else.render(opts); + return code; + } + optimizeNodes() { + super.optimizeNodes(); + const cond = this.condition; + if (cond === true) + return this.nodes; + let e = this.else; + if (e) { + const ns = e.optimizeNodes(); + e = this.else = Array.isArray(ns) ? new Else(ns) : ns; + } + if (e) { + if (cond === false) + return e instanceof _If ? e : e.nodes; + if (this.nodes.length) + return this; + return new _If(not(cond), e instanceof _If ? [e] : e.nodes); + } + if (cond === false || !this.nodes.length) + return void 0; + return this; + } + optimizeNames(names, constants) { + var _a2; + this.else = (_a2 = this.else) === null || _a2 === void 0 ? void 0 : _a2.optimizeNames(names, constants); + if (!(super.optimizeNames(names, constants) || this.else)) + return; + this.condition = optimizeExpr(this.condition, names, constants); + return this; + } + get names() { + const names = super.names; + addExprNames(names, this.condition); + if (this.else) + addNames(names, this.else.names); + return names; + } + }; + If.kind = "if"; + var For = class extends BlockNode { + }; + For.kind = "for"; + var ForLoop = class extends For { + constructor(iteration) { + super(); + this.iteration = iteration; + } + render(opts) { + return `for(${this.iteration})` + super.render(opts); + } + optimizeNames(names, constants) { + if (!super.optimizeNames(names, constants)) + return; + this.iteration = optimizeExpr(this.iteration, names, constants); + return this; + } + get names() { + return addNames(super.names, this.iteration.names); + } + }; + var ForRange = class extends For { + constructor(varKind, name, from, to) { + super(); + this.varKind = varKind; + this.name = name; + this.from = from; + this.to = to; + } + render(opts) { + const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind; + const { name, from, to } = this; + return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts); + } + get names() { + const names = addExprNames(super.names, this.from); + return addExprNames(names, this.to); + } + }; + var ForIter = class extends For { + constructor(loop, varKind, name, iterable) { + super(); + this.loop = loop; + this.varKind = varKind; + this.name = name; + this.iterable = iterable; + } + render(opts) { + return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts); + } + optimizeNames(names, constants) { + if (!super.optimizeNames(names, constants)) + return; + this.iterable = optimizeExpr(this.iterable, names, constants); + return this; + } + get names() { + return addNames(super.names, this.iterable.names); + } + }; + var Func = class extends BlockNode { + constructor(name, args, async) { + super(); + this.name = name; + this.args = args; + this.async = async; + } + render(opts) { + const _async = this.async ? "async " : ""; + return `${_async}function ${this.name}(${this.args})` + super.render(opts); + } + }; + Func.kind = "func"; + var Return = class extends ParentNode { + render(opts) { + return "return " + super.render(opts); + } + }; + Return.kind = "return"; + var Try = class extends BlockNode { + render(opts) { + let code = "try" + super.render(opts); + if (this.catch) + code += this.catch.render(opts); + if (this.finally) + code += this.finally.render(opts); + return code; + } + optimizeNodes() { + var _a2, _b; + super.optimizeNodes(); + (_a2 = this.catch) === null || _a2 === void 0 ? void 0 : _a2.optimizeNodes(); + (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes(); + return this; + } + optimizeNames(names, constants) { + var _a2, _b; + super.optimizeNames(names, constants); + (_a2 = this.catch) === null || _a2 === void 0 ? void 0 : _a2.optimizeNames(names, constants); + (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants); + return this; + } + get names() { + const names = super.names; + if (this.catch) + addNames(names, this.catch.names); + if (this.finally) + addNames(names, this.finally.names); + return names; + } + }; + var Catch = class extends BlockNode { + constructor(error2) { + super(); + this.error = error2; + } + render(opts) { + return `catch(${this.error})` + super.render(opts); + } + }; + Catch.kind = "catch"; + var Finally = class extends BlockNode { + render(opts) { + return "finally" + super.render(opts); + } + }; + Finally.kind = "finally"; + var CodeGen = class { + constructor(extScope, opts = {}) { + this._values = {}; + this._blockStarts = []; + this._constants = {}; + this.opts = { ...opts, _n: opts.lines ? "\n" : "" }; + this._extScope = extScope; + this._scope = new scope_1.Scope({ parent: extScope }); + this._nodes = [new Root()]; + } + toString() { + return this._root.render(this.opts); + } + // returns unique name in the internal scope + name(prefix) { + return this._scope.name(prefix); + } + // reserves unique name in the external scope + scopeName(prefix) { + return this._extScope.name(prefix); + } + // reserves unique name in the external scope and assigns value to it + scopeValue(prefixOrName, value) { + const name = this._extScope.value(prefixOrName, value); + const vs = this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set()); + vs.add(name); + return name; + } + getScopeValue(prefix, keyOrRef) { + return this._extScope.getValue(prefix, keyOrRef); + } + // return code that assigns values in the external scope to the names that are used internally + // (same names that were returned by gen.scopeName or gen.scopeValue) + scopeRefs(scopeName) { + return this._extScope.scopeRefs(scopeName, this._values); + } + scopeCode() { + return this._extScope.scopeCode(this._values); + } + _def(varKind, nameOrPrefix, rhs, constant) { + const name = this._scope.toName(nameOrPrefix); + if (rhs !== void 0 && constant) + this._constants[name.str] = rhs; + this._leafNode(new Def(varKind, name, rhs)); + return name; + } + // `const` declaration (`var` in es5 mode) + const(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant); + } + // `let` declaration with optional assignment (`var` in es5 mode) + let(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant); + } + // `var` declaration with optional assignment + var(nameOrPrefix, rhs, _constant) { + return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant); + } + // assignment code + assign(lhs, rhs, sideEffects) { + return this._leafNode(new Assign(lhs, rhs, sideEffects)); + } + // `+=` code + add(lhs, rhs) { + return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs)); + } + // appends passed SafeExpr to code or executes Block + code(c) { + if (typeof c == "function") + c(); + else if (c !== code_1.nil) + this._leafNode(new AnyCode(c)); + return this; + } + // returns code for object literal for the passed argument list of key-value pairs + object(...keyValues) { + const code = ["{"]; + for (const [key, value] of keyValues) { + if (code.length > 1) + code.push(","); + code.push(key); + if (key !== value || this.opts.es5) { + code.push(":"); + (0, code_1.addCodeArg)(code, value); + } + } + code.push("}"); + return new code_1._Code(code); + } + // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed) + if(condition, thenBody, elseBody) { + this._blockNode(new If(condition)); + if (thenBody && elseBody) { + this.code(thenBody).else().code(elseBody).endIf(); + } else if (thenBody) { + this.code(thenBody).endIf(); + } else if (elseBody) { + throw new Error('CodeGen: "else" body without "then" body'); + } + return this; + } + // `else if` clause - invalid without `if` or after `else` clauses + elseIf(condition) { + return this._elseNode(new If(condition)); + } + // `else` clause - only valid after `if` or `else if` clauses + else() { + return this._elseNode(new Else()); + } + // end `if` statement (needed if gen.if was used only with condition) + endIf() { + return this._endBlockNode(If, Else); + } + _for(node, forBody) { + this._blockNode(node); + if (forBody) + this.code(forBody).endFor(); + return this; + } + // a generic `for` clause (or statement if `forBody` is passed) + for(iteration, forBody) { + return this._for(new ForLoop(iteration), forBody); + } + // `for` statement for a range of values + forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) { + const name = this._scope.toName(nameOrPrefix); + return this._for(new ForRange(varKind, name, from, to), () => forBody(name)); + } + // `for-of` statement (in es5 mode replace with a normal for loop) + forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) { + const name = this._scope.toName(nameOrPrefix); + if (this.opts.es5) { + const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable); + return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => { + this.var(name, (0, code_1._)`${arr}[${i}]`); + forBody(name); + }); + } + return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name)); + } + // `for-in` statement. + // With option `ownProperties` replaced with a `for-of` loop for object keys + forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) { + if (this.opts.ownProperties) { + return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody); + } + const name = this._scope.toName(nameOrPrefix); + return this._for(new ForIter("in", varKind, name, obj), () => forBody(name)); + } + // end `for` loop + endFor() { + return this._endBlockNode(For); + } + // `label` statement + label(label) { + return this._leafNode(new Label(label)); + } + // `break` statement + break(label) { + return this._leafNode(new Break(label)); + } + // `return` statement + return(value) { + const node = new Return(); + this._blockNode(node); + this.code(value); + if (node.nodes.length !== 1) + throw new Error('CodeGen: "return" should have one node'); + return this._endBlockNode(Return); + } + // `try` statement + try(tryBody, catchCode, finallyCode) { + if (!catchCode && !finallyCode) + throw new Error('CodeGen: "try" without "catch" and "finally"'); + const node = new Try(); + this._blockNode(node); + this.code(tryBody); + if (catchCode) { + const error2 = this.name("e"); + this._currNode = node.catch = new Catch(error2); + catchCode(error2); + } + if (finallyCode) { + this._currNode = node.finally = new Finally(); + this.code(finallyCode); + } + return this._endBlockNode(Catch, Finally); + } + // `throw` statement + throw(error2) { + return this._leafNode(new Throw(error2)); + } + // start self-balancing block + block(body, nodeCount) { + this._blockStarts.push(this._nodes.length); + if (body) + this.code(body).endBlock(nodeCount); + return this; + } + // end the current self-balancing block + endBlock(nodeCount) { + const len = this._blockStarts.pop(); + if (len === void 0) + throw new Error("CodeGen: not in self-balancing block"); + const toClose = this._nodes.length - len; + if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) { + throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`); + } + this._nodes.length = len; + return this; + } + // `function` heading (or definition if funcBody is passed) + func(name, args = code_1.nil, async, funcBody) { + this._blockNode(new Func(name, args, async)); + if (funcBody) + this.code(funcBody).endFunc(); + return this; + } + // end function definition + endFunc() { + return this._endBlockNode(Func); + } + optimize(n = 1) { + while (n-- > 0) { + this._root.optimizeNodes(); + this._root.optimizeNames(this._root.names, this._constants); + } + } + _leafNode(node) { + this._currNode.nodes.push(node); + return this; + } + _blockNode(node) { + this._currNode.nodes.push(node); + this._nodes.push(node); + } + _endBlockNode(N1, N2) { + const n = this._currNode; + if (n instanceof N1 || N2 && n instanceof N2) { + this._nodes.pop(); + return this; + } + throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`); + } + _elseNode(node) { + const n = this._currNode; + if (!(n instanceof If)) { + throw new Error('CodeGen: "else" without "if"'); + } + this._currNode = n.else = node; + return this; + } + get _root() { + return this._nodes[0]; + } + get _currNode() { + const ns = this._nodes; + return ns[ns.length - 1]; + } + set _currNode(node) { + const ns = this._nodes; + ns[ns.length - 1] = node; + } + }; + exports.CodeGen = CodeGen; + function addNames(names, from) { + for (const n in from) + names[n] = (names[n] || 0) + (from[n] || 0); + return names; + } + function addExprNames(names, from) { + return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names; + } + function optimizeExpr(expr, names, constants) { + if (expr instanceof code_1.Name) + return replaceName(expr); + if (!canOptimize(expr)) + return expr; + return new code_1._Code(expr._items.reduce((items, c) => { + if (c instanceof code_1.Name) + c = replaceName(c); + if (c instanceof code_1._Code) + items.push(...c._items); + else + items.push(c); + return items; + }, [])); + function replaceName(n) { + const c = constants[n.str]; + if (c === void 0 || names[n.str] !== 1) + return n; + delete names[n.str]; + return c; + } + function canOptimize(e) { + return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0); + } + } + function subtractNames(names, from) { + for (const n in from) + names[n] = (names[n] || 0) - (from[n] || 0); + } + function not(x) { + return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`; + } + exports.not = not; + var andCode = mappend(exports.operators.AND); + function and(...args) { + return args.reduce(andCode); + } + exports.and = and; + var orCode = mappend(exports.operators.OR); + function or(...args) { + return args.reduce(orCode); + } + exports.or = or; + function mappend(op) { + return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`; + } + function par(x) { + return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`; + } + } +}); + +// node_modules/ajv/dist/compile/util.js +var require_util = __commonJS({ + "node_modules/ajv/dist/compile/util.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0; + var codegen_1 = require_codegen(); + var code_1 = require_code(); + function toHash(arr) { + const hash2 = {}; + for (const item of arr) + hash2[item] = true; + return hash2; + } + exports.toHash = toHash; + function alwaysValidSchema(it, schema) { + if (typeof schema == "boolean") + return schema; + if (Object.keys(schema).length === 0) + return true; + checkUnknownRules(it, schema); + return !schemaHasRules(schema, it.self.RULES.all); + } + exports.alwaysValidSchema = alwaysValidSchema; + function checkUnknownRules(it, schema = it.schema) { + const { opts, self } = it; + if (!opts.strictSchema) + return; + if (typeof schema === "boolean") + return; + const rules = self.RULES.keywords; + for (const key in schema) { + if (!rules[key]) + checkStrictMode(it, `unknown keyword: "${key}"`); + } + } + exports.checkUnknownRules = checkUnknownRules; + function schemaHasRules(schema, rules) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (rules[key]) + return true; + return false; + } + exports.schemaHasRules = schemaHasRules; + function schemaHasRulesButRef(schema, RULES) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (key !== "$ref" && RULES.all[key]) + return true; + return false; + } + exports.schemaHasRulesButRef = schemaHasRulesButRef; + function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) { + if (!$data) { + if (typeof schema == "number" || typeof schema == "boolean") + return schema; + if (typeof schema == "string") + return (0, codegen_1._)`${schema}`; + } + return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`; + } + exports.schemaRefOrVal = schemaRefOrVal; + function unescapeFragment(str) { + return unescapeJsonPointer(decodeURIComponent(str)); + } + exports.unescapeFragment = unescapeFragment; + function escapeFragment(str) { + return encodeURIComponent(escapeJsonPointer(str)); + } + exports.escapeFragment = escapeFragment; + function escapeJsonPointer(str) { + if (typeof str == "number") + return `${str}`; + return str.replace(/~/g, "~0").replace(/\//g, "~1"); + } + exports.escapeJsonPointer = escapeJsonPointer; + function unescapeJsonPointer(str) { + return str.replace(/~1/g, "/").replace(/~0/g, "~"); + } + exports.unescapeJsonPointer = unescapeJsonPointer; + function eachItem(xs, f) { + if (Array.isArray(xs)) { + for (const x of xs) + f(x); + } else { + f(xs); + } + } + exports.eachItem = eachItem; + function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues: mergeValues3, resultToName }) { + return (gen, from, to, toName) => { + const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues3(from, to); + return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res; + }; + } + exports.mergeEvaluated = { + props: makeMergeEvaluated({ + mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => { + gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`)); + }), + mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => { + if (from === true) { + gen.assign(to, true); + } else { + gen.assign(to, (0, codegen_1._)`${to} || {}`); + setEvaluated(gen, to, from); + } + }), + mergeValues: (from, to) => from === true ? true : { ...from, ...to }, + resultToName: evaluatedPropsToName + }), + items: makeMergeEvaluated({ + mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)), + mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)), + mergeValues: (from, to) => from === true ? true : Math.max(from, to), + resultToName: (gen, items) => gen.var("items", items) + }) + }; + function evaluatedPropsToName(gen, ps) { + if (ps === true) + return gen.var("props", true); + const props = gen.var("props", (0, codegen_1._)`{}`); + if (ps !== void 0) + setEvaluated(gen, props, ps); + return props; + } + exports.evaluatedPropsToName = evaluatedPropsToName; + function setEvaluated(gen, props, ps) { + Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true)); + } + exports.setEvaluated = setEvaluated; + var snippets = {}; + function useFunc(gen, f) { + return gen.scopeValue("func", { + ref: f, + code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code)) + }); + } + exports.useFunc = useFunc; + var Type; + (function(Type2) { + Type2[Type2["Num"] = 0] = "Num"; + Type2[Type2["Str"] = 1] = "Str"; + })(Type || (exports.Type = Type = {})); + function getErrorPath(dataProp, dataPropType, jsPropertySyntax) { + if (dataProp instanceof codegen_1.Name) { + const isNumber = dataPropType === Type.Num; + return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`; + } + return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp); + } + exports.getErrorPath = getErrorPath; + function checkStrictMode(it, msg, mode = it.opts.strictSchema) { + if (!mode) + return; + msg = `strict mode: ${msg}`; + if (mode === true) + throw new Error(msg); + it.self.logger.warn(msg); + } + exports.checkStrictMode = checkStrictMode; + } +}); + +// node_modules/ajv/dist/compile/names.js +var require_names = __commonJS({ + "node_modules/ajv/dist/compile/names.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var names = { + // validation function arguments + data: new codegen_1.Name("data"), + // data passed to validation function + // args passed from referencing schema + valCxt: new codegen_1.Name("valCxt"), + // validation/data context - should not be used directly, it is destructured to the names below + instancePath: new codegen_1.Name("instancePath"), + parentData: new codegen_1.Name("parentData"), + parentDataProperty: new codegen_1.Name("parentDataProperty"), + rootData: new codegen_1.Name("rootData"), + // root data - same as the data passed to the first/top validation function + dynamicAnchors: new codegen_1.Name("dynamicAnchors"), + // used to support recursiveRef and dynamicRef + // function scoped variables + vErrors: new codegen_1.Name("vErrors"), + // null or array of validation errors + errors: new codegen_1.Name("errors"), + // counter of validation errors + this: new codegen_1.Name("this"), + // "globals" + self: new codegen_1.Name("self"), + scope: new codegen_1.Name("scope"), + // JTD serialize/parse name for JSON string and position + json: new codegen_1.Name("json"), + jsonPos: new codegen_1.Name("jsonPos"), + jsonLen: new codegen_1.Name("jsonLen"), + jsonPart: new codegen_1.Name("jsonPart") + }; + exports.default = names; + } +}); + +// node_modules/ajv/dist/compile/errors.js +var require_errors = __commonJS({ + "node_modules/ajv/dist/compile/errors.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var names_1 = require_names(); + exports.keywordError = { + message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation` + }; + exports.keyword$DataError = { + message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)` + }; + function reportError(cxt, error2 = exports.keywordError, errorPaths, overrideAllErrors) { + const { it } = cxt; + const { gen, compositeRule, allErrors } = it; + const errObj = errorObjectCode(cxt, error2, errorPaths); + if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) { + addError(gen, errObj); + } else { + returnErrors(it, (0, codegen_1._)`[${errObj}]`); + } + } + exports.reportError = reportError; + function reportExtraError(cxt, error2 = exports.keywordError, errorPaths) { + const { it } = cxt; + const { gen, compositeRule, allErrors } = it; + const errObj = errorObjectCode(cxt, error2, errorPaths); + addError(gen, errObj); + if (!(compositeRule || allErrors)) { + returnErrors(it, names_1.default.vErrors); + } + } + exports.reportExtraError = reportExtraError; + function resetErrorsCount(gen, errsCount) { + gen.assign(names_1.default.errors, errsCount); + gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null))); + } + exports.resetErrorsCount = resetErrorsCount; + function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) { + if (errsCount === void 0) + throw new Error("ajv implementation error"); + const err = gen.name("err"); + gen.forRange("i", errsCount, names_1.default.errors, (i) => { + gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`); + gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath))); + gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`); + if (it.opts.verbose) { + gen.assign((0, codegen_1._)`${err}.schema`, schemaValue); + gen.assign((0, codegen_1._)`${err}.data`, data); + } + }); + } + exports.extendErrors = extendErrors; + function addError(gen, errObj) { + const err = gen.const("err", errObj); + gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`); + gen.code((0, codegen_1._)`${names_1.default.errors}++`); + } + function returnErrors(it, errs) { + const { gen, validateName, schemaEnv } = it; + if (schemaEnv.$async) { + gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`); + } else { + gen.assign((0, codegen_1._)`${validateName}.errors`, errs); + gen.return(false); + } + } + var E = { + keyword: new codegen_1.Name("keyword"), + schemaPath: new codegen_1.Name("schemaPath"), + // also used in JTD errors + params: new codegen_1.Name("params"), + propertyName: new codegen_1.Name("propertyName"), + message: new codegen_1.Name("message"), + schema: new codegen_1.Name("schema"), + parentSchema: new codegen_1.Name("parentSchema") + }; + function errorObjectCode(cxt, error2, errorPaths) { + const { createErrors } = cxt.it; + if (createErrors === false) + return (0, codegen_1._)`{}`; + return errorObject(cxt, error2, errorPaths); + } + function errorObject(cxt, error2, errorPaths = {}) { + const { gen, it } = cxt; + const keyValues = [ + errorInstancePath(it, errorPaths), + errorSchemaPath(cxt, errorPaths) + ]; + extraErrorProps(cxt, error2, keyValues); + return gen.object(...keyValues); + } + function errorInstancePath({ errorPath }, { instancePath }) { + const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath; + return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)]; + } + function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) { + let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`; + if (schemaPath) { + schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`; + } + return [E.schemaPath, schPath]; + } + function extraErrorProps(cxt, { params, message }, keyValues) { + const { keyword, data, schemaValue, it } = cxt; + const { opts, propertyName, topSchemaRef, schemaPath } = it; + keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]); + if (opts.messages) { + keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]); + } + if (opts.verbose) { + keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]); + } + if (propertyName) + keyValues.push([E.propertyName, propertyName]); + } + } +}); + +// node_modules/ajv/dist/compile/validate/boolSchema.js +var require_boolSchema = __commonJS({ + "node_modules/ajv/dist/compile/validate/boolSchema.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0; + var errors_1 = require_errors(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var boolError = { + message: "boolean schema is false" + }; + function topBoolOrEmptySchema(it) { + const { gen, schema, validateName } = it; + if (schema === false) { + falseSchemaError(it, false); + } else if (typeof schema == "object" && schema.$async === true) { + gen.return(names_1.default.data); + } else { + gen.assign((0, codegen_1._)`${validateName}.errors`, null); + gen.return(true); + } + } + exports.topBoolOrEmptySchema = topBoolOrEmptySchema; + function boolOrEmptySchema(it, valid) { + const { gen, schema } = it; + if (schema === false) { + gen.var(valid, false); + falseSchemaError(it); + } else { + gen.var(valid, true); + } + } + exports.boolOrEmptySchema = boolOrEmptySchema; + function falseSchemaError(it, overrideAllErrors) { + const { gen, data } = it; + const cxt = { + gen, + keyword: "false schema", + data, + schema: false, + schemaCode: false, + schemaValue: false, + params: {}, + it + }; + (0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors); + } + } +}); + +// node_modules/ajv/dist/compile/rules.js +var require_rules = __commonJS({ + "node_modules/ajv/dist/compile/rules.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getRules = exports.isJSONType = void 0; + var _jsonTypes = ["string", "number", "integer", "boolean", "null", "object", "array"]; + var jsonTypes = new Set(_jsonTypes); + function isJSONType(x) { + return typeof x == "string" && jsonTypes.has(x); + } + exports.isJSONType = isJSONType; + function getRules() { + const groups = { + number: { type: "number", rules: [] }, + string: { type: "string", rules: [] }, + array: { type: "array", rules: [] }, + object: { type: "object", rules: [] } + }; + return { + types: { ...groups, integer: true, boolean: true, null: true }, + rules: [{ rules: [] }, groups.number, groups.string, groups.array, groups.object], + post: { rules: [] }, + all: {}, + keywords: {} + }; + } + exports.getRules = getRules; + } +}); + +// node_modules/ajv/dist/compile/validate/applicability.js +var require_applicability = __commonJS({ + "node_modules/ajv/dist/compile/validate/applicability.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0; + function schemaHasRulesForType({ schema, self }, type) { + const group = self.RULES.types[type]; + return group && group !== true && shouldUseGroup(schema, group); + } + exports.schemaHasRulesForType = schemaHasRulesForType; + function shouldUseGroup(schema, group) { + return group.rules.some((rule) => shouldUseRule(schema, rule)); + } + exports.shouldUseGroup = shouldUseGroup; + function shouldUseRule(schema, rule) { + var _a2; + return schema[rule.keyword] !== void 0 || ((_a2 = rule.definition.implements) === null || _a2 === void 0 ? void 0 : _a2.some((kwd) => schema[kwd] !== void 0)); + } + exports.shouldUseRule = shouldUseRule; + } +}); + +// node_modules/ajv/dist/compile/validate/dataType.js +var require_dataType = __commonJS({ + "node_modules/ajv/dist/compile/validate/dataType.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0; + var rules_1 = require_rules(); + var applicability_1 = require_applicability(); + var errors_1 = require_errors(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var DataType; + (function(DataType2) { + DataType2[DataType2["Correct"] = 0] = "Correct"; + DataType2[DataType2["Wrong"] = 1] = "Wrong"; + })(DataType || (exports.DataType = DataType = {})); + function getSchemaTypes(schema) { + const types = getJSONTypes(schema.type); + const hasNull = types.includes("null"); + if (hasNull) { + if (schema.nullable === false) + throw new Error("type: null contradicts nullable: false"); + } else { + if (!types.length && schema.nullable !== void 0) { + throw new Error('"nullable" cannot be used without "type"'); + } + if (schema.nullable === true) + types.push("null"); + } + return types; + } + exports.getSchemaTypes = getSchemaTypes; + function getJSONTypes(ts) { + const types = Array.isArray(ts) ? ts : ts ? [ts] : []; + if (types.every(rules_1.isJSONType)) + return types; + throw new Error("type must be JSONType or JSONType[]: " + types.join(",")); + } + exports.getJSONTypes = getJSONTypes; + function coerceAndCheckDataType(it, types) { + const { gen, data, opts } = it; + const coerceTo = coerceToTypes(types, opts.coerceTypes); + const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0])); + if (checkTypes) { + const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong); + gen.if(wrongType, () => { + if (coerceTo.length) + coerceData(it, types, coerceTo); + else + reportTypeError(it); + }); + } + return checkTypes; + } + exports.coerceAndCheckDataType = coerceAndCheckDataType; + var COERCIBLE = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]); + function coerceToTypes(types, coerceTypes) { + return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : []; + } + function coerceData(it, types, coerceTo) { + const { gen, data, opts } = it; + const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`); + const coerced = gen.let("coerced", (0, codegen_1._)`undefined`); + if (opts.coerceTypes === "array") { + gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data))); + } + gen.if((0, codegen_1._)`${coerced} !== undefined`); + for (const t of coerceTo) { + if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") { + coerceSpecificType(t); + } + } + gen.else(); + reportTypeError(it); + gen.endIf(); + gen.if((0, codegen_1._)`${coerced} !== undefined`, () => { + gen.assign(data, coerced); + assignParentData(it, coerced); + }); + function coerceSpecificType(t) { + switch (t) { + case "string": + gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`); + return; + case "number": + gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null + || (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`); + return; + case "integer": + gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null + || (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`); + return; + case "boolean": + gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true); + return; + case "null": + gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`); + gen.assign(coerced, null); + return; + case "array": + gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number" + || ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`); + } + } + } + function assignParentData({ gen, parentData, parentDataProperty }, expr) { + gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr)); + } + function checkDataType(dataType, data, strictNums, correct = DataType.Correct) { + const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ; + let cond; + switch (dataType) { + case "null": + return (0, codegen_1._)`${data} ${EQ} null`; + case "array": + cond = (0, codegen_1._)`Array.isArray(${data})`; + break; + case "object": + cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`; + break; + case "integer": + cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`); + break; + case "number": + cond = numCond(); + break; + default: + return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`; + } + return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond); + function numCond(_cond = codegen_1.nil) { + return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil); + } + } + exports.checkDataType = checkDataType; + function checkDataTypes(dataTypes, data, strictNums, correct) { + if (dataTypes.length === 1) { + return checkDataType(dataTypes[0], data, strictNums, correct); + } + let cond; + const types = (0, util_1.toHash)(dataTypes); + if (types.array && types.object) { + const notObj = (0, codegen_1._)`typeof ${data} != "object"`; + cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`; + delete types.null; + delete types.array; + delete types.object; + } else { + cond = codegen_1.nil; + } + if (types.number) + delete types.integer; + for (const t in types) + cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct)); + return cond; + } + exports.checkDataTypes = checkDataTypes; + var typeError = { + message: ({ schema }) => `must be ${schema}`, + params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}` + }; + function reportTypeError(it) { + const cxt = getTypeErrorContext(it); + (0, errors_1.reportError)(cxt, typeError); + } + exports.reportTypeError = reportTypeError; + function getTypeErrorContext(it) { + const { gen, data, schema } = it; + const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type"); + return { + gen, + keyword: "type", + data, + schema: schema.type, + schemaCode, + schemaValue: schemaCode, + parentSchema: schema, + params: {}, + it + }; + } + } +}); + +// node_modules/ajv/dist/compile/validate/defaults.js +var require_defaults = __commonJS({ + "node_modules/ajv/dist/compile/validate/defaults.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.assignDefaults = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + function assignDefaults(it, ty) { + const { properties, items } = it.schema; + if (ty === "object" && properties) { + for (const key in properties) { + assignDefault(it, key, properties[key].default); + } + } else if (ty === "array" && Array.isArray(items)) { + items.forEach((sch, i) => assignDefault(it, i, sch.default)); + } + } + exports.assignDefaults = assignDefaults; + function assignDefault(it, prop, defaultValue) { + const { gen, compositeRule, data, opts } = it; + if (defaultValue === void 0) + return; + const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`; + if (compositeRule) { + (0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`); + return; + } + let condition = (0, codegen_1._)`${childData} === undefined`; + if (opts.useDefaults === "empty") { + condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`; + } + gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`); + } + } +}); + +// node_modules/ajv/dist/vocabularies/code.js +var require_code2 = __commonJS({ + "node_modules/ajv/dist/vocabularies/code.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var names_1 = require_names(); + var util_2 = require_util(); + function checkReportMissingProp(cxt, prop) { + const { gen, data, it } = cxt; + gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => { + cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true); + cxt.error(); + }); + } + exports.checkReportMissingProp = checkReportMissingProp; + function checkMissingProp({ gen, data, it: { opts } }, properties, missing) { + return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`))); + } + exports.checkMissingProp = checkMissingProp; + function reportMissingProp(cxt, missing) { + cxt.setParams({ missingProperty: missing }, true); + cxt.error(); + } + exports.reportMissingProp = reportMissingProp; + function hasPropFunc(gen) { + return gen.scopeValue("func", { + // eslint-disable-next-line @typescript-eslint/unbound-method + ref: Object.prototype.hasOwnProperty, + code: (0, codegen_1._)`Object.prototype.hasOwnProperty` + }); + } + exports.hasPropFunc = hasPropFunc; + function isOwnProperty(gen, data, property) { + return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`; + } + exports.isOwnProperty = isOwnProperty; + function propertyInData(gen, data, property, ownProperties) { + const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`; + return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond; + } + exports.propertyInData = propertyInData; + function noPropertyInData(gen, data, property, ownProperties) { + const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`; + return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond; + } + exports.noPropertyInData = noPropertyInData; + function allSchemaProperties(schemaMap) { + return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : []; + } + exports.allSchemaProperties = allSchemaProperties; + function schemaProperties(it, schemaMap) { + return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p])); + } + exports.schemaProperties = schemaProperties; + function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) { + const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data; + const valCxt = [ + [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)], + [names_1.default.parentData, it.parentData], + [names_1.default.parentDataProperty, it.parentDataProperty], + [names_1.default.rootData, names_1.default.rootData] + ]; + if (it.opts.dynamicRef) + valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]); + const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`; + return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`; + } + exports.callValidateCode = callValidateCode; + var newRegExp = (0, codegen_1._)`new RegExp`; + function usePattern({ gen, it: { opts } }, pattern) { + const u = opts.unicodeRegExp ? "u" : ""; + const { regExp } = opts.code; + const rx = regExp(pattern, u); + return gen.scopeValue("pattern", { + key: rx.toString(), + ref: rx, + code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})` + }); + } + exports.usePattern = usePattern; + function validateArray(cxt) { + const { gen, data, keyword, it } = cxt; + const valid = gen.name("valid"); + if (it.allErrors) { + const validArr = gen.let("valid", true); + validateItems(() => gen.assign(validArr, false)); + return validArr; + } + gen.var(valid, true); + validateItems(() => gen.break()); + return valid; + function validateItems(notValid) { + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + gen.forRange("i", 0, len, (i) => { + cxt.subschema({ + keyword, + dataProp: i, + dataPropType: util_1.Type.Num + }, valid); + gen.if((0, codegen_1.not)(valid), notValid); + }); + } + } + exports.validateArray = validateArray; + function validateUnion(cxt) { + const { gen, schema, keyword, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)); + if (alwaysValid && !it.opts.unevaluated) + return; + const valid = gen.let("valid", false); + const schValid = gen.name("_valid"); + gen.block(() => schema.forEach((_sch, i) => { + const schCxt = cxt.subschema({ + keyword, + schemaProp: i, + compositeRule: true + }, schValid); + gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`); + const merged = cxt.mergeValidEvaluated(schCxt, schValid); + if (!merged) + gen.if((0, codegen_1.not)(valid)); + })); + cxt.result(valid, () => cxt.reset(), () => cxt.error(true)); + } + exports.validateUnion = validateUnion; + } +}); + +// node_modules/ajv/dist/compile/validate/keyword.js +var require_keyword = __commonJS({ + "node_modules/ajv/dist/compile/validate/keyword.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0; + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var code_1 = require_code2(); + var errors_1 = require_errors(); + function macroKeywordCode(cxt, def) { + const { gen, keyword, schema, parentSchema, it } = cxt; + const macroSchema = def.macro.call(it.self, schema, parentSchema, it); + const schemaRef = useKeyword(gen, keyword, macroSchema); + if (it.opts.validateSchema !== false) + it.self.validateSchema(macroSchema, true); + const valid = gen.name("valid"); + cxt.subschema({ + schema: macroSchema, + schemaPath: codegen_1.nil, + errSchemaPath: `${it.errSchemaPath}/${keyword}`, + topSchemaRef: schemaRef, + compositeRule: true + }, valid); + cxt.pass(valid, () => cxt.error(true)); + } + exports.macroKeywordCode = macroKeywordCode; + function funcKeywordCode(cxt, def) { + var _a2; + const { gen, keyword, schema, parentSchema, $data, it } = cxt; + checkAsyncKeyword(it, def); + 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((_a2 = def.valid) !== null && _a2 !== void 0 ? _a2 : valid); + function validateKeyword() { + if (def.errors === false) { + assignValid(); + if (def.modifying) + modifyData(cxt); + reportErrs(() => cxt.error()); + } else { + const ruleErrs = def.async ? validateAsync() : validateSync(); + if (def.modifying) + modifyData(cxt); + reportErrs(() => addErrs(cxt, ruleErrs)); + } + } + function validateAsync() { + const ruleErrs = gen.let("ruleErrs", null); + gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e))); + return ruleErrs; + } + function validateSync() { + const validateErrs = (0, codegen_1._)`${validateRef}.errors`; + gen.assign(validateErrs, null); + assignValid(codegen_1.nil); + return validateErrs; + } + function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) { + const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self; + const passSchema = !("compile" in def && !$data || def.schema === false); + gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying); + } + function reportErrs(errors) { + var _a3; + gen.if((0, codegen_1.not)((_a3 = def.valid) !== null && _a3 !== void 0 ? _a3 : valid), errors); + } + } + exports.funcKeywordCode = funcKeywordCode; + function modifyData(cxt) { + const { gen, data, it } = cxt; + gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`)); + } + function addErrs(cxt, errs) { + const { gen } = cxt; + gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => { + gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`); + (0, errors_1.extendErrors)(cxt); + }, () => cxt.error()); + } + function checkAsyncKeyword({ schemaEnv }, def) { + if (def.async && !schemaEnv.$async) + throw new Error("async keyword in sync schema"); + } + function useKeyword(gen, keyword, result) { + if (result === void 0) + throw new Error(`keyword "${keyword}" failed to compile`); + return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) }); + } + function validSchemaType(schema, schemaType, allowUndefined = false) { + return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined"); + } + exports.validSchemaType = validSchemaType; + function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) { + if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) { + throw new Error("ajv implementation error"); + } + const deps = def.dependencies; + if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) { + throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`); + } + if (def.validateSchema) { + const valid = def.validateSchema(schema[keyword]); + if (!valid) { + const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors); + if (opts.validateSchema === "log") + self.logger.error(msg); + else + throw new Error(msg); + } + } + } + exports.validateKeywordUsage = validateKeywordUsage; + } +}); + +// node_modules/ajv/dist/compile/validate/subschema.js +var require_subschema = __commonJS({ + "node_modules/ajv/dist/compile/validate/subschema.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) { + if (keyword !== void 0 && schema !== void 0) { + throw new Error('both "keyword" and "schema" passed, only one allowed'); + } + if (keyword !== void 0) { + const sch = it.schema[keyword]; + return schemaProp === void 0 ? { + schema: sch, + schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`, + errSchemaPath: `${it.errSchemaPath}/${keyword}` + } : { + schema: sch[schemaProp], + schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`, + errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}` + }; + } + if (schema !== void 0) { + if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) { + throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"'); + } + return { + schema, + schemaPath, + topSchemaRef, + errSchemaPath + }; + } + throw new Error('either "keyword" or "schema" must be passed'); + } + exports.getSubschema = getSubschema; + function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) { + if (data !== void 0 && dataProp !== void 0) { + throw new Error('both "data" and "dataProp" passed, only one allowed'); + } + const { gen } = it; + if (dataProp !== void 0) { + const { errorPath, dataPathArr, opts } = it; + const nextData = gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true); + dataContextProps(nextData); + subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`; + subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`; + subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty]; + } + if (data !== void 0) { + const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true); + dataContextProps(nextData); + if (propertyName !== void 0) + subschema.propertyName = propertyName; + } + if (dataTypes) + subschema.dataTypes = dataTypes; + function dataContextProps(_nextData) { + subschema.data = _nextData; + subschema.dataLevel = it.dataLevel + 1; + subschema.dataTypes = []; + it.definedProperties = /* @__PURE__ */ new Set(); + subschema.parentData = it.data; + subschema.dataNames = [...it.dataNames, _nextData]; + } + } + exports.extendSubschemaData = extendSubschemaData; + function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) { + if (compositeRule !== void 0) + subschema.compositeRule = compositeRule; + if (createErrors !== void 0) + subschema.createErrors = createErrors; + if (allErrors !== void 0) + subschema.allErrors = allErrors; + subschema.jtdDiscriminator = jtdDiscriminator; + subschema.jtdMetadata = jtdMetadata; + } + exports.extendSubschemaMode = extendSubschemaMode; + } +}); + +// node_modules/fast-deep-equal/index.js +var require_fast_deep_equal = __commonJS({ + "node_modules/fast-deep-equal/index.js"(exports, module) { + "use strict"; + module.exports = function equal(a, b) { + if (a === b) return true; + if (a && b && typeof a == "object" && typeof b == "object") { + if (a.constructor !== b.constructor) return false; + var length, i, keys; + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0; ) + if (!equal(a[i], b[i])) return false; + return true; + } + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + for (i = length; i-- !== 0; ) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + for (i = length; i-- !== 0; ) { + var key = keys[i]; + if (!equal(a[key], b[key])) return false; + } + return true; + } + return a !== a && b !== b; + }; + } +}); + +// node_modules/json-schema-traverse/index.js +var require_json_schema_traverse = __commonJS({ + "node_modules/json-schema-traverse/index.js"(exports, module) { + "use strict"; + var traverse = module.exports = function(schema, opts, cb) { + if (typeof opts == "function") { + cb = opts; + opts = {}; + } + cb = opts.cb || cb; + var pre = typeof cb == "function" ? cb : cb.pre || function() { + }; + var post = cb.post || function() { + }; + _traverse(opts, pre, post, schema, "", schema); + }; + traverse.keywords = { + additionalItems: true, + items: true, + contains: true, + additionalProperties: true, + propertyNames: true, + not: true, + if: true, + then: true, + else: true + }; + traverse.arrayKeywords = { + items: true, + allOf: true, + anyOf: true, + oneOf: true + }; + traverse.propsKeywords = { + $defs: true, + definitions: true, + properties: true, + patternProperties: true, + dependencies: true + }; + traverse.skipKeywords = { + default: true, + enum: true, + const: true, + required: 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 + }; + function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { + if (schema && typeof schema == "object" && !Array.isArray(schema)) { + pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + for (var key in schema) { + var sch = schema[key]; + if (Array.isArray(sch)) { + if (key in traverse.arrayKeywords) { + for (var i = 0; i < sch.length; i++) + _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i); + } + } else if (key in traverse.propsKeywords) { + if (sch && typeof sch == "object") { + for (var prop in sch) + _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop); + } + } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) { + _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema); + } + } + post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + } + } + function escapeJsonPtr(str) { + return str.replace(/~/g, "~0").replace(/\//g, "~1"); + } + } +}); + +// node_modules/ajv/dist/compile/resolve.js +var require_resolve = __commonJS({ + "node_modules/ajv/dist/compile/resolve.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0; + var util_1 = require_util(); + var equal = require_fast_deep_equal(); + var traverse = require_json_schema_traverse(); + var SIMPLE_INLINED = /* @__PURE__ */ new Set([ + "type", + "format", + "pattern", + "maxLength", + "minLength", + "maxProperties", + "minProperties", + "maxItems", + "minItems", + "maximum", + "minimum", + "uniqueItems", + "multipleOf", + "required", + "enum", + "const" + ]); + function inlineRef(schema, limit = true) { + if (typeof schema == "boolean") + return true; + if (limit === true) + return !hasRef(schema); + if (!limit) + return false; + return countKeys(schema) <= limit; + } + exports.inlineRef = inlineRef; + var REF_KEYWORDS = /* @__PURE__ */ new Set([ + "$ref", + "$recursiveRef", + "$recursiveAnchor", + "$dynamicRef", + "$dynamicAnchor" + ]); + function hasRef(schema) { + for (const key in schema) { + if (REF_KEYWORDS.has(key)) + return true; + const sch = schema[key]; + if (Array.isArray(sch) && sch.some(hasRef)) + return true; + if (typeof sch == "object" && hasRef(sch)) + return true; + } + return false; + } + function countKeys(schema) { + let count = 0; + for (const key in schema) { + if (key === "$ref") + return Infinity; + count++; + if (SIMPLE_INLINED.has(key)) + continue; + if (typeof schema[key] == "object") { + (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch)); + } + if (count === Infinity) + return Infinity; + } + return count; + } + function getFullPath(resolver, id = "", normalize) { + if (normalize !== false) + id = normalizeId(id); + const p = resolver.parse(id); + return _getFullPath(resolver, p); + } + exports.getFullPath = getFullPath; + function _getFullPath(resolver, p) { + const serialized = resolver.serialize(p); + return serialized.split("#")[0] + "#"; + } + exports._getFullPath = _getFullPath; + var TRAILING_SLASH_HASH = /#\/?$/; + function normalizeId(id) { + return id ? id.replace(TRAILING_SLASH_HASH, "") : ""; + } + exports.normalizeId = normalizeId; + function resolveUrl(resolver, baseId, id) { + id = normalizeId(id); + return resolver.resolve(baseId, id); + } + exports.resolveUrl = resolveUrl; + var ANCHOR = /^[a-z_][-a-z0-9._]*$/i; + function getSchemaRefs(schema, baseId) { + if (typeof schema == "boolean") + return {}; + const { schemaId, uriResolver } = this.opts; + const schId = normalizeId(schema[schemaId] || baseId); + const baseIds = { "": schId }; + const pathPrefix = getFullPath(uriResolver, schId, false); + const localRefs = {}; + const schemaRefs = /* @__PURE__ */ new Set(); + traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => { + if (parentJsonPtr === void 0) + return; + const fullPath = pathPrefix + jsonPtr; + let innerBaseId = baseIds[parentJsonPtr]; + if (typeof sch[schemaId] == "string") + innerBaseId = addRef.call(this, sch[schemaId]); + addAnchor.call(this, sch.$anchor); + addAnchor.call(this, sch.$dynamicAnchor); + baseIds[jsonPtr] = innerBaseId; + function addRef(ref) { + const _resolve = this.opts.uriResolver.resolve; + ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref); + if (schemaRefs.has(ref)) + throw ambiguos(ref); + schemaRefs.add(ref); + let schOrRef = this.refs[ref]; + if (typeof schOrRef == "string") + schOrRef = this.refs[schOrRef]; + if (typeof schOrRef == "object") { + checkAmbiguosRef(sch, schOrRef.schema, ref); + } else if (ref !== normalizeId(fullPath)) { + if (ref[0] === "#") { + checkAmbiguosRef(sch, localRefs[ref], ref); + localRefs[ref] = sch; + } else { + this.refs[ref] = fullPath; + } + } + return ref; + } + function addAnchor(anchor) { + if (typeof anchor == "string") { + if (!ANCHOR.test(anchor)) + throw new Error(`invalid anchor "${anchor}"`); + addRef.call(this, `#${anchor}`); + } + } + }); + return localRefs; + function checkAmbiguosRef(sch1, sch2, ref) { + if (sch2 !== void 0 && !equal(sch1, sch2)) + throw ambiguos(ref); + } + function ambiguos(ref) { + return new Error(`reference "${ref}" resolves to more than one schema`); + } + } + exports.getSchemaRefs = getSchemaRefs; + } +}); + +// node_modules/ajv/dist/compile/validate/index.js +var require_validate = __commonJS({ + "node_modules/ajv/dist/compile/validate/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0; + var boolSchema_1 = require_boolSchema(); + var dataType_1 = require_dataType(); + var applicability_1 = require_applicability(); + var dataType_2 = require_dataType(); + var defaults_1 = require_defaults(); + var keyword_1 = require_keyword(); + var subschema_1 = require_subschema(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var resolve_1 = require_resolve(); + var util_1 = require_util(); + var errors_1 = require_errors(); + function validateFunctionCode(it) { + if (isSchemaObj(it)) { + checkKeywords(it); + if (schemaCxtHasRules(it)) { + topSchemaObjCode(it); + return; + } + } + validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it)); + } + exports.validateFunctionCode = validateFunctionCode; + function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) { + if (opts.code.es5) { + gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => { + gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`); + destructureValCxtES5(gen, opts); + gen.code(body); + }); + } else { + gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body)); + } + } + function destructureValCxt(opts) { + return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`; + } + function destructureValCxtES5(gen, opts) { + gen.if(names_1.default.valCxt, () => { + gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`); + gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`); + gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`); + gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`); + if (opts.dynamicRef) + gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`); + }, () => { + gen.var(names_1.default.instancePath, (0, codegen_1._)`""`); + gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`); + gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`); + gen.var(names_1.default.rootData, names_1.default.data); + if (opts.dynamicRef) + gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`); + }); + } + function topSchemaObjCode(it) { + const { schema, opts, gen } = it; + validateFunction(it, () => { + if (opts.$comment && schema.$comment) + commentKeyword(it); + checkNoDefault(it); + gen.let(names_1.default.vErrors, null); + gen.let(names_1.default.errors, 0); + if (opts.unevaluated) + resetEvaluated(it); + typeAndKeywords(it); + returnResults(it); + }); + return; + } + function resetEvaluated(it) { + const { gen, validateName } = it; + it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`); + gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`)); + gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`)); + } + function funcSourceUrl(schema, opts) { + const schId = typeof schema == "object" && schema[opts.schemaId]; + return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil; + } + function subschemaCode(it, valid) { + if (isSchemaObj(it)) { + checkKeywords(it); + if (schemaCxtHasRules(it)) { + subSchemaObjCode(it, valid); + return; + } + } + (0, boolSchema_1.boolOrEmptySchema)(it, valid); + } + function schemaCxtHasRules({ schema, self }) { + if (typeof schema == "boolean") + return !schema; + for (const key in schema) + if (self.RULES.all[key]) + return true; + return false; + } + function isSchemaObj(it) { + return typeof it.schema != "boolean"; + } + function subSchemaObjCode(it, valid) { + const { schema, gen, opts } = it; + if (opts.$comment && schema.$comment) + commentKeyword(it); + updateContext(it); + checkAsyncSchema(it); + const errsCount = gen.const("_errs", names_1.default.errors); + typeAndKeywords(it, errsCount); + gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`); + } + function checkKeywords(it) { + (0, util_1.checkUnknownRules)(it); + checkRefsAndKeywords(it); + } + function typeAndKeywords(it, errsCount) { + if (it.opts.jtd) + return schemaKeywords(it, [], false, errsCount); + const types = (0, dataType_1.getSchemaTypes)(it.schema); + const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types); + schemaKeywords(it, types, !checkedTypes, errsCount); + } + function checkRefsAndKeywords(it) { + const { schema, errSchemaPath, opts, self } = it; + if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) { + self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`); + } + } + function checkNoDefault(it) { + const { schema, opts } = it; + if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) { + (0, util_1.checkStrictMode)(it, "default is ignored in the schema root"); + } + } + function updateContext(it) { + const schId = it.schema[it.opts.schemaId]; + if (schId) + it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId); + } + function checkAsyncSchema(it) { + if (it.schema.$async && !it.schemaEnv.$async) + throw new Error("async schema in sync schema"); + } + function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) { + const msg = schema.$comment; + if (opts.$comment === true) { + gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`); + } else if (typeof opts.$comment == "function") { + const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`; + const rootName = gen.scopeValue("root", { ref: schemaEnv.root }); + gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`); + } + } + function returnResults(it) { + const { gen, schemaEnv, validateName, ValidationError, opts } = it; + if (schemaEnv.$async) { + gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`)); + } else { + gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors); + if (opts.unevaluated) + assignEvaluated(it); + gen.return((0, codegen_1._)`${names_1.default.errors} === 0`); + } + } + function assignEvaluated({ gen, evaluated, props, items }) { + if (props instanceof codegen_1.Name) + gen.assign((0, codegen_1._)`${evaluated}.props`, props); + if (items instanceof codegen_1.Name) + gen.assign((0, codegen_1._)`${evaluated}.items`, items); + } + function schemaKeywords(it, types, typeErrors, errsCount) { + const { gen, schema, data, allErrors, opts, self } = it; + const { RULES } = self; + if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) { + gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition)); + return; + } + if (!opts.jtd) + checkStrictTypes(it, types); + gen.block(() => { + for (const group of RULES.rules) + groupKeywords(group); + groupKeywords(RULES.post); + }); + function groupKeywords(group) { + if (!(0, applicability_1.shouldUseGroup)(schema, group)) + return; + if (group.type) { + gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers)); + iterateKeywords(it, group); + if (types.length === 1 && types[0] === group.type && typeErrors) { + gen.else(); + (0, dataType_2.reportTypeError)(it); + } + gen.endIf(); + } else { + iterateKeywords(it, group); + } + if (!allErrors) + gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`); + } + } + function iterateKeywords(it, group) { + const { gen, schema, opts: { useDefaults } } = it; + if (useDefaults) + (0, defaults_1.assignDefaults)(it, group.type); + gen.block(() => { + for (const rule of group.rules) { + if ((0, applicability_1.shouldUseRule)(schema, rule)) { + keywordCode(it, rule.keyword, rule.definition, group.type); + } + } + }); + } + function checkStrictTypes(it, types) { + if (it.schemaEnv.meta || !it.opts.strictTypes) + return; + checkContextTypes(it, types); + if (!it.opts.allowUnionTypes) + checkMultipleTypes(it, types); + checkKeywordTypes(it, it.dataTypes); + } + function checkContextTypes(it, types) { + if (!types.length) + return; + if (!it.dataTypes.length) { + it.dataTypes = types; + return; + } + types.forEach((t) => { + if (!includesType(it.dataTypes, t)) { + strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`); + } + }); + narrowSchemaTypes(it, types); + } + function checkMultipleTypes(it, ts) { + if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) { + strictTypesError(it, "use allowUnionTypes to allow union type keyword"); + } + } + function checkKeywordTypes(it, ts) { + const rules = it.self.RULES.all; + for (const keyword in rules) { + const rule = rules[keyword]; + if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) { + const { type } = rule.definition; + if (type.length && !type.some((t) => hasApplicableType(ts, t))) { + strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`); + } + } + } + } + function hasApplicableType(schTs, kwdT) { + return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer"); + } + function includesType(ts, t) { + return ts.includes(t) || t === "integer" && ts.includes("number"); + } + function narrowSchemaTypes(it, withTypes) { + const ts = []; + for (const t of it.dataTypes) { + if (includesType(withTypes, t)) + ts.push(t); + else if (withTypes.includes("integer") && t === "number") + ts.push("integer"); + } + it.dataTypes = ts; + } + function strictTypesError(it, msg) { + const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; + msg += ` at "${schemaPath}" (strictTypes)`; + (0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes); + } + var KeywordCxt = class { + constructor(it, def, keyword) { + (0, keyword_1.validateKeywordUsage)(it, def, keyword); + this.gen = it.gen; + this.allErrors = it.allErrors; + this.keyword = keyword; + this.data = it.data; + this.schema = it.schema[keyword]; + this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data; + this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data); + this.schemaType = def.schemaType; + this.parentSchema = it.schema; + this.params = {}; + this.it = it; + this.def = def; + if (this.$data) { + this.schemaCode = it.gen.const("vSchema", getData(this.$data, it)); + } else { + this.schemaCode = this.schemaValue; + if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) { + throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`); + } + } + if ("code" in def ? def.trackErrors : def.errors !== false) { + this.errsCount = it.gen.const("_errs", names_1.default.errors); + } + } + result(condition, successAction, failAction) { + this.failResult((0, codegen_1.not)(condition), successAction, failAction); + } + failResult(condition, successAction, failAction) { + this.gen.if(condition); + if (failAction) + failAction(); + else + this.error(); + if (successAction) { + this.gen.else(); + successAction(); + if (this.allErrors) + this.gen.endIf(); + } else { + if (this.allErrors) + this.gen.endIf(); + else + this.gen.else(); + } + } + pass(condition, failAction) { + this.failResult((0, codegen_1.not)(condition), void 0, failAction); + } + fail(condition) { + if (condition === void 0) { + this.error(); + if (!this.allErrors) + this.gen.if(false); + return; + } + this.gen.if(condition); + this.error(); + if (this.allErrors) + this.gen.endIf(); + else + this.gen.else(); + } + fail$data(condition) { + if (!this.$data) + return this.fail(condition); + const { schemaCode } = this; + this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`); + } + error(append, errorParams, errorPaths) { + if (errorParams) { + this.setParams(errorParams); + this._error(append, errorPaths); + this.setParams({}); + return; + } + this._error(append, errorPaths); + } + _error(append, errorPaths) { + ; + (append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths); + } + $dataError() { + (0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError); + } + reset() { + if (this.errsCount === void 0) + throw new Error('add "trackErrors" to keyword definition'); + (0, errors_1.resetErrorsCount)(this.gen, this.errsCount); + } + ok(cond) { + if (!this.allErrors) + this.gen.if(cond); + } + setParams(obj, assign) { + if (assign) + Object.assign(this.params, obj); + else + this.params = obj; + } + block$data(valid, codeBlock, $dataValid = codegen_1.nil) { + this.gen.block(() => { + this.check$data(valid, $dataValid); + codeBlock(); + }); + } + check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) { + if (!this.$data) + return; + const { gen, schemaCode, schemaType, def } = this; + gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid)); + if (valid !== codegen_1.nil) + gen.assign(valid, true); + if (schemaType.length || def.validateSchema) { + gen.elseIf(this.invalid$data()); + this.$dataError(); + if (valid !== codegen_1.nil) + gen.assign(valid, false); + } + gen.else(); + } + invalid$data() { + const { gen, schemaCode, schemaType, def, it } = this; + return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema()); + function wrong$DataType() { + if (schemaType.length) { + if (!(schemaCode instanceof codegen_1.Name)) + throw new Error("ajv implementation error"); + const st = Array.isArray(schemaType) ? schemaType : [schemaType]; + return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`; + } + return codegen_1.nil; + } + function invalid$DataSchema() { + if (def.validateSchema) { + const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema }); + return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`; + } + return codegen_1.nil; + } + } + subschema(appl, valid) { + const subschema = (0, subschema_1.getSubschema)(this.it, appl); + (0, subschema_1.extendSubschemaData)(subschema, this.it, appl); + (0, subschema_1.extendSubschemaMode)(subschema, appl); + const nextContext = { ...this.it, ...subschema, items: void 0, props: void 0 }; + subschemaCode(nextContext, valid); + return nextContext; + } + mergeEvaluated(schemaCxt, toName) { + const { it, gen } = this; + if (!it.opts.unevaluated) + return; + if (it.props !== true && schemaCxt.props !== void 0) { + it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName); + } + if (it.items !== true && schemaCxt.items !== void 0) { + it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName); + } + } + mergeValidEvaluated(schemaCxt, valid) { + const { it, gen } = this; + if (it.opts.unevaluated && (it.props !== true || it.items !== true)) { + gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name)); + return true; + } + } + }; + exports.KeywordCxt = KeywordCxt; + function keywordCode(it, keyword, def, ruleType) { + const cxt = new KeywordCxt(it, def, keyword); + if ("code" in def) { + def.code(cxt, ruleType); + } else if (cxt.$data && def.validate) { + (0, keyword_1.funcKeywordCode)(cxt, def); + } else if ("macro" in def) { + (0, keyword_1.macroKeywordCode)(cxt, def); + } else if (def.compile || def.validate) { + (0, keyword_1.funcKeywordCode)(cxt, def); + } + } + 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_POINTER.test($data)) + throw new Error(`Invalid JSON-pointer: ${$data}`); + jsonPointer = $data; + data = names_1.default.rootData; + } else { + const matches = RELATIVE_JSON_POINTER.exec($data); + if (!matches) + throw new Error(`Invalid JSON-pointer: ${$data}`); + const up = +matches[1]; + jsonPointer = matches[2]; + if (jsonPointer === "#") { + if (up >= dataLevel) + throw new Error(errorMsg("property/index", up)); + return dataPathArr[dataLevel - up]; + } + if (up > dataLevel) + throw new Error(errorMsg("data", up)); + data = dataNames[dataLevel - up]; + if (!jsonPointer) + return data; + } + let expr = data; + const segments = jsonPointer.split("/"); + for (const segment of segments) { + if (segment) { + data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`; + expr = (0, codegen_1._)`${expr} && ${data}`; + } + } + return expr; + function errorMsg(pointerType, up) { + return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`; + } + } + exports.getData = getData; + } +}); + +// node_modules/ajv/dist/runtime/validation_error.js +var require_validation_error = __commonJS({ + "node_modules/ajv/dist/runtime/validation_error.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var ValidationError = class extends Error { + constructor(errors) { + super("validation failed"); + this.errors = errors; + this.ajv = this.validation = true; + } + }; + exports.default = ValidationError; + } +}); + +// node_modules/ajv/dist/compile/ref_error.js +var require_ref_error = __commonJS({ + "node_modules/ajv/dist/compile/ref_error.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var resolve_1 = require_resolve(); + var MissingRefError = class extends Error { + constructor(resolver, baseId, ref, msg) { + super(msg || `can't resolve reference ${ref} from id ${baseId}`); + this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref); + this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef)); + } + }; + exports.default = MissingRefError; + } +}); + +// node_modules/ajv/dist/compile/index.js +var require_compile = __commonJS({ + "node_modules/ajv/dist/compile/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0; + var codegen_1 = require_codegen(); + var validation_error_1 = require_validation_error(); + var names_1 = require_names(); + var resolve_1 = require_resolve(); + var util_1 = require_util(); + var validate_1 = require_validate(); + var SchemaEnv = class { + constructor(env2) { + var _a2; + this.refs = {}; + this.dynamicAnchors = {}; + let schema; + if (typeof env2.schema == "object") + schema = env2.schema; + this.schema = env2.schema; + this.schemaId = env2.schemaId; + this.root = env2.root || this; + this.baseId = (_a2 = env2.baseId) !== null && _a2 !== void 0 ? _a2 : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env2.schemaId || "$id"]); + this.schemaPath = env2.schemaPath; + this.localRefs = env2.localRefs; + this.meta = env2.meta; + this.$async = schema === null || schema === void 0 ? void 0 : schema.$async; + this.refs = {}; + } + }; + exports.SchemaEnv = SchemaEnv; + function compileSchema(sch) { + const _sch = getCompilingSchema.call(this, sch); + if (_sch) + return _sch; + const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId); + const { es5, lines } = this.opts.code; + const { ownProperties } = this.opts; + const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties }); + let _ValidationError; + if (sch.$async) { + _ValidationError = gen.scopeValue("Error", { + ref: validation_error_1.default, + code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default` + }); + } + const validateName = gen.scopeName("validate"); + sch.validateName = validateName; + const schemaCxt = { + gen, + allErrors: this.opts.allErrors, + data: names_1.default.data, + parentData: names_1.default.parentData, + parentDataProperty: names_1.default.parentDataProperty, + dataNames: [names_1.default.data], + dataPathArr: [codegen_1.nil], + // TODO can its length be used as dataLevel if nil is removed? + dataLevel: 0, + dataTypes: [], + definedProperties: /* @__PURE__ */ new Set(), + topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? { ref: sch.schema, code: (0, codegen_1.stringify)(sch.schema) } : { ref: sch.schema }), + validateName, + ValidationError: _ValidationError, + schema: sch.schema, + schemaEnv: sch, + rootId, + baseId: sch.baseId || rootId, + schemaPath: codegen_1.nil, + errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"), + errorPath: (0, codegen_1._)`""`, + opts: this.opts, + self: this + }; + let sourceCode; + try { + this._compilations.add(sch); + (0, validate_1.validateFunctionCode)(schemaCxt); + gen.optimize(this.opts.code.optimize); + const validateCode = gen.toString(); + sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`; + 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 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) + validate.$async = true; + if (this.opts.code.source === true) { + validate.source = { validateName, validateCode, scopeValues: gen._values }; + } + if (this.opts.unevaluated) { + const { props, items } = schemaCxt; + 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 (validate.source) + validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated); + } + sch.validate = validate; + return sch; + } catch (e) { + delete sch.validate; + delete sch.validateName; + if (sourceCode) + this.logger.error("Error compiling schema, function code:", sourceCode); + throw e; + } finally { + this._compilations.delete(sch); + } + } + exports.compileSchema = compileSchema; + function resolveRef(root, baseId, ref) { + var _a2; + ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref); + const schOrFunc = root.refs[ref]; + if (schOrFunc) + return schOrFunc; + let _sch = resolve.call(this, root, ref); + if (_sch === void 0) { + const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref]; + const { schemaId } = this.opts; + if (schema) + _sch = new SchemaEnv({ schema, schemaId, root, baseId }); + } + if (_sch === void 0) + return; + return root.refs[ref] = inlineOrCompile.call(this, _sch); + } + exports.resolveRef = resolveRef; + function inlineOrCompile(sch) { + if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs)) + return sch.schema; + return sch.validate ? sch : compileSchema.call(this, sch); + } + function getCompilingSchema(schEnv) { + for (const sch of this._compilations) { + if (sameSchemaEnv(sch, schEnv)) + return sch; + } + } + exports.getCompilingSchema = getCompilingSchema; + function sameSchemaEnv(s1, s2) { + return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId; + } + function resolve(root, ref) { + let sch; + while (typeof (sch = this.refs[ref]) == "string") + ref = sch; + return sch || this.schemas[ref] || resolveSchema.call(this, root, ref); + } + function resolveSchema(root, ref) { + const p = this.opts.uriResolver.parse(ref); + const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p); + let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0); + if (Object.keys(root.schema).length > 0 && refPath === baseId) { + return getJsonPointer.call(this, p, root); + } + const id = (0, resolve_1.normalizeId)(refPath); + const schOrRef = this.refs[id] || this.schemas[id]; + if (typeof schOrRef == "string") { + const sch = resolveSchema.call(this, root, schOrRef); + if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") + return; + return getJsonPointer.call(this, p, sch); + } + if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object") + return; + if (!schOrRef.validate) + compileSchema.call(this, schOrRef); + if (id === (0, resolve_1.normalizeId)(ref)) { + const { schema } = schOrRef; + const { schemaId } = this.opts; + const schId = schema[schemaId]; + if (schId) + baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId); + return new SchemaEnv({ schema, schemaId, root, baseId }); + } + return getJsonPointer.call(this, p, schOrRef); + } + exports.resolveSchema = resolveSchema; + var PREVENT_SCOPE_CHANGE = /* @__PURE__ */ new Set([ + "properties", + "patternProperties", + "enum", + "dependencies", + "definitions" + ]); + function getJsonPointer(parsedRef, { baseId, schema, root }) { + var _a2; + if (((_a2 = parsedRef.fragment) === null || _a2 === void 0 ? void 0 : _a2[0]) !== "/") + return; + for (const part of parsedRef.fragment.slice(1).split("/")) { + if (typeof schema === "boolean") + return; + const partSchema = schema[(0, util_1.unescapeFragment)(part)]; + if (partSchema === void 0) + return; + schema = partSchema; + const schId = typeof schema === "object" && schema[this.opts.schemaId]; + if (!PREVENT_SCOPE_CHANGE.has(part) && schId) { + baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId); + } + } + let env2; + if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) { + const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref); + env2 = resolveSchema.call(this, root, $ref); + } + const { schemaId } = this.opts; + env2 = env2 || new SchemaEnv({ schema, schemaId, root, baseId }); + if (env2.schema !== env2.root.schema) + return env2; + return void 0; + } + } +}); + +// node_modules/ajv/dist/refs/data.json +var require_data = __commonJS({ + "node_modules/ajv/dist/refs/data.json"(exports, module) { + module.exports = { + $id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", + description: "Meta-schema for $data reference (JSON AnySchema extension proposal)", + type: "object", + required: ["$data"], + properties: { + $data: { + type: "string", + anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }] + } + }, + additionalProperties: false + }; + } +}); + +// node_modules/fast-uri/lib/utils.js +var require_utils = __commonJS({ + "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); + function stringArrayToHexStripped(input) { + let acc = ""; + let code = 0; + let i = 0; + for (i = 0; i < input.length; i++) { + code = input[i].charCodeAt(0); + if (code === 48) { + continue; + } + if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) { + return ""; + } + acc += input[i]; + break; + } + for (i += 1; i < input.length; i++) { + code = input[i].charCodeAt(0); + if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) { + return ""; + } + acc += input[i]; + } + return acc; + } + 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 hex3 = stringArrayToHexStripped(buffer); + if (hex3 !== "") { + address.push(hex3); + } else { + output.error = true; + return false; + } + buffer.length = 0; + } + 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; + } + 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); + continue; + } + } + if (buffer.length) { + if (consume === consumeIsZone) { + output.zone = buffer.join(""); + } else if (endIpv6) { + address.push(buffer.join("")); + } else { + address.push(stringArrayToHexStripped(buffer)); + } + } + output.address = address.join(""); + return output; + } + function normalizeIPv6(host) { + if (findToken(host, ":") < 2) { + return { host, isIPV6: false }; + } + const ipv63 = getIPV6(host); + if (!ipv63.error) { + let newHost = ipv63.address; + let escapedHost = ipv63.address; + if (ipv63.zone) { + newHost += "%" + ipv63.zone; + escapedHost += "%25" + ipv63.zone; + } + return { host: newHost, isIPV6: true, escapedHost }; + } else { + return { host, isIPV6: false }; + } + } + function findToken(str, token) { + let ind = 0; + for (let i = 0; i < str.length; i++) { + if (str[i] === token) ind++; + } + return ind; + } + function removeDotSegments(path3) { + let input = path3; + const output = []; + let nextSlash = -1; + let len = 0; + while (len = input.length) { + if (len === 1) { + if (input === ".") { + break; + } else if (input === "/") { + output.push("/"); + break; + } else { + output.push(input); + break; + } + } else if (len === 2) { + if (input[0] === ".") { + if (input[1] === ".") { + break; + } else if (input[1] === "/") { + input = input.slice(2); + continue; + } + } else if (input[0] === "/") { + if (input[1] === "." || input[1] === "/") { + output.push("/"); + break; + } + } + } else if (len === 3) { + if (input === "/..") { + if (output.length !== 0) { + output.pop(); + } + output.push("/"); + break; + } + } + if (input[0] === ".") { + if (input[1] === ".") { + if (input[2] === "/") { + input = input.slice(3); + continue; + } + } else if (input[1] === "/") { + input = input.slice(2); + continue; + } + } else if (input[0] === "/") { + if (input[1] === ".") { + if (input[2] === "/") { + input = input.slice(2); + continue; + } else if (input[2] === ".") { + if (input[3] === "/") { + input = input.slice(3); + if (output.length !== 0) { + output.pop(); + } + continue; + } + } + } + } + if ((nextSlash = input.indexOf("/", 1)) === -1) { + output.push(input); + break; + } else { + output.push(input.slice(0, nextSlash)); + input = input.slice(nextSlash); + } + } + return output.join(""); + } + function normalizeComponentEncoding(component, esc2) { + const func = esc2 !== true ? escape : unescape; + if (component.scheme !== void 0) { + component.scheme = func(component.scheme); + } + if (component.userinfo !== void 0) { + component.userinfo = func(component.userinfo); + } + if (component.host !== void 0) { + component.host = func(component.host); + } + if (component.path !== void 0) { + component.path = func(component.path); + } + if (component.query !== void 0) { + component.query = func(component.query); + } + if (component.fragment !== void 0) { + component.fragment = func(component.fragment); + } + return component; + } + function recomposeAuthority(component) { + const uriTokens = []; + if (component.userinfo !== void 0) { + uriTokens.push(component.userinfo); + uriTokens.push("@"); + } + if (component.host !== void 0) { + let host = unescape(component.host); + if (!isIPv4(host)) { + const ipV6res = normalizeIPv6(host); + if (ipV6res.isIPV6 === true) { + host = `[${ipV6res.escapedHost}]`; + } else { + host = component.host; + } + } + uriTokens.push(host); + } + if (typeof component.port === "number" || typeof component.port === "string") { + uriTokens.push(":"); + uriTokens.push(String(component.port)); + } + return uriTokens.length ? uriTokens.join("") : void 0; + } + module.exports = { + nonSimpleDomain, + recomposeAuthority, + normalizeComponentEncoding, + removeDotSegments, + isIPv4, + isUUID, + normalizeIPv6, + stringArrayToHexStripped + }; + } +}); + +// node_modules/fast-uri/lib/schemes.js +var require_schemes = __commonJS({ + "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 supportedSchemeNames = ( + /** @type {const} */ + [ + "http", + "https", + "ws", + "wss", + "urn", + "urn:uuid" + ] + ); + function isValidSchemeName(name) { + return supportedSchemeNames.indexOf( + /** @type {*} */ + name + ) !== -1; + } + function wsIsSecure(wsComponent) { + if (wsComponent.secure === true) { + return true; + } else if (wsComponent.secure === false) { + return false; + } else if (wsComponent.scheme) { + return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S"); + } else { + return false; + } + } + function httpParse(component) { + if (!component.host) { + component.error = component.error || "HTTP URIs must have a host."; + } + return component; + } + function httpSerialize(component) { + const secure = String(component.scheme).toLowerCase() === "https"; + if (component.port === (secure ? 443 : 80) || component.port === "") { + component.port = void 0; + } + if (!component.path) { + component.path = "/"; + } + return component; + } + function wsParse(wsComponent) { + wsComponent.secure = wsIsSecure(wsComponent); + wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : ""); + wsComponent.path = void 0; + wsComponent.query = void 0; + return wsComponent; + } + function wsSerialize(wsComponent) { + if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") { + wsComponent.port = void 0; + } + if (typeof wsComponent.secure === "boolean") { + wsComponent.scheme = wsComponent.secure ? "wss" : "ws"; + wsComponent.secure = void 0; + } + if (wsComponent.resourceName) { + const [path3, query] = wsComponent.resourceName.split("?"); + wsComponent.path = path3 && path3 !== "/" ? path3 : void 0; + wsComponent.query = query; + wsComponent.resourceName = void 0; + } + wsComponent.fragment = void 0; + return wsComponent; + } + function urnParse(urnComponent, options) { + if (!urnComponent.path) { + urnComponent.error = "URN can not be parsed"; + return urnComponent; + } + const matches = urnComponent.path.match(URN_REG); + if (matches) { + const scheme = options.scheme || urnComponent.scheme || "urn"; + urnComponent.nid = matches[1].toLowerCase(); + urnComponent.nss = matches[2]; + const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`; + const schemeHandler = getSchemeHandler(urnScheme); + urnComponent.path = void 0; + if (schemeHandler) { + urnComponent = schemeHandler.parse(urnComponent, options); + } + } else { + urnComponent.error = urnComponent.error || "URN can not be parsed."; + } + return urnComponent; + } + function urnSerialize(urnComponent, options) { + if (urnComponent.nid === void 0) { + throw new Error("URN without nid cannot be serialized"); + } + const scheme = options.scheme || urnComponent.scheme || "urn"; + const nid = urnComponent.nid.toLowerCase(); + const urnScheme = `${scheme}:${options.nid || nid}`; + const schemeHandler = getSchemeHandler(urnScheme); + if (schemeHandler) { + urnComponent = schemeHandler.serialize(urnComponent, options); + } + const uriComponent = urnComponent; + const nss = urnComponent.nss; + uriComponent.path = `${nid || options.nid}:${nss}`; + options.skipEscape = true; + return uriComponent; + } + function urnuuidParse(urnComponent, options) { + const uuidComponent = urnComponent; + uuidComponent.uuid = uuidComponent.nss; + uuidComponent.nss = void 0; + if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) { + uuidComponent.error = uuidComponent.error || "UUID is not valid."; + } + return uuidComponent; + } + function urnuuidSerialize(uuidComponent) { + const urnComponent = uuidComponent; + urnComponent.nss = (uuidComponent.uuid || "").toLowerCase(); + return urnComponent; + } + var http = ( + /** @type {SchemeHandler} */ + { + scheme: "http", + domainHost: true, + parse: httpParse, + serialize: httpSerialize + } + ); + var https = ( + /** @type {SchemeHandler} */ + { + scheme: "https", + domainHost: http.domainHost, + parse: httpParse, + serialize: httpSerialize + } + ); + var ws = ( + /** @type {SchemeHandler} */ + { + scheme: "ws", + domainHost: true, + parse: wsParse, + serialize: wsSerialize + } + ); + var wss2 = ( + /** @type {SchemeHandler} */ + { + scheme: "wss", + domainHost: ws.domainHost, + parse: ws.parse, + serialize: ws.serialize + } + ); + var urn = ( + /** @type {SchemeHandler} */ + { + scheme: "urn", + parse: urnParse, + serialize: urnSerialize, + skipNormalize: true + } + ); + var urnuuid = ( + /** @type {SchemeHandler} */ + { + scheme: "urn:uuid", + parse: urnuuidParse, + serialize: urnuuidSerialize, + skipNormalize: true + } + ); + var SCHEMES = ( + /** @type {Record} */ + { + http, + https, + ws, + wss: wss2, + urn, + "urn:uuid": urnuuid + } + ); + Object.setPrototypeOf(SCHEMES, null); + function getSchemeHandler(scheme) { + return scheme && (SCHEMES[ + /** @type {SchemeName} */ + scheme + ] || SCHEMES[ + /** @type {SchemeName} */ + scheme.toLowerCase() + ]) || void 0; + } + module.exports = { + wsIsSecure, + SCHEMES, + isValidSchemeName, + getSchemeHandler + }; + } +}); + +// node_modules/fast-uri/index.js +var require_fast_uri = __commonJS({ + "node_modules/fast-uri/index.js"(exports, module) { + "use strict"; + var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils(); + var { SCHEMES, getSchemeHandler } = require_schemes(); + function normalize(uri, options) { + if (typeof uri === "string") { + uri = /** @type {T} */ + serialize(parse4(uri, options), options); + } else if (typeof uri === "object") { + uri = /** @type {T} */ + parse4(serialize(uri, options), options); + } + return uri; + } + function resolve(baseURI, relativeURI, options) { + const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" }; + const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true); + schemelessOptions.skipEscape = true; + return serialize(resolved, schemelessOptions); + } + function resolveComponent(base, relative, options, skipNormalization) { + const target = {}; + if (!skipNormalization) { + base = parse4(serialize(base, options), options); + relative = parse4(serialize(relative, options), options); + } + options = options || {}; + if (!options.tolerant && relative.scheme) { + target.scheme = relative.scheme; + target.userinfo = relative.userinfo; + target.host = relative.host; + target.port = relative.port; + target.path = removeDotSegments(relative.path || ""); + target.query = relative.query; + } else { + if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) { + target.userinfo = relative.userinfo; + target.host = relative.host; + target.port = relative.port; + target.path = removeDotSegments(relative.path || ""); + target.query = relative.query; + } else { + if (!relative.path) { + target.path = base.path; + if (relative.query !== void 0) { + target.query = relative.query; + } else { + target.query = base.query; + } + } else { + if (relative.path[0] === "/") { + target.path = removeDotSegments(relative.path); + } else { + if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) { + target.path = "/" + relative.path; + } else if (!base.path) { + target.path = relative.path; + } else { + target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path; + } + target.path = removeDotSegments(target.path); + } + target.query = relative.query; + } + target.userinfo = base.userinfo; + target.host = base.host; + target.port = base.port; + } + target.scheme = base.scheme; + } + target.fragment = relative.fragment; + return target; + } + function equal(uriA, uriB, options) { + if (typeof uriA === "string") { + uriA = unescape(uriA); + uriA = serialize(normalizeComponentEncoding(parse4(uriA, options), true), { ...options, skipEscape: true }); + } else if (typeof uriA === "object") { + uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true }); + } + if (typeof uriB === "string") { + uriB = unescape(uriB); + uriB = serialize(normalizeComponentEncoding(parse4(uriB, options), true), { ...options, skipEscape: true }); + } else if (typeof uriB === "object") { + uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true }); + } + return uriA.toLowerCase() === uriB.toLowerCase(); + } + function serialize(cmpts, opts) { + const component = { + host: cmpts.host, + scheme: cmpts.scheme, + userinfo: cmpts.userinfo, + port: cmpts.port, + path: cmpts.path, + query: cmpts.query, + nid: cmpts.nid, + nss: cmpts.nss, + uuid: cmpts.uuid, + fragment: cmpts.fragment, + reference: cmpts.reference, + resourceName: cmpts.resourceName, + secure: cmpts.secure, + error: "" + }; + const options = Object.assign({}, opts); + const uriTokens = []; + const schemeHandler = getSchemeHandler(options.scheme || component.scheme); + if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options); + if (component.path !== void 0) { + if (!options.skipEscape) { + component.path = escape(component.path); + if (component.scheme !== void 0) { + component.path = component.path.split("%3A").join(":"); + } + } else { + component.path = unescape(component.path); + } + } + if (options.reference !== "suffix" && component.scheme) { + uriTokens.push(component.scheme, ":"); + } + const authority = recomposeAuthority(component); + if (authority !== void 0) { + if (options.reference !== "suffix") { + uriTokens.push("//"); + } + uriTokens.push(authority); + if (component.path && component.path[0] !== "/") { + uriTokens.push("/"); + } + } + if (component.path !== void 0) { + let s = component.path; + if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) { + s = removeDotSegments(s); + } + 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); + } + if (component.fragment !== void 0) { + uriTokens.push("#", component.fragment); + } + return uriTokens.join(""); + } + var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u; + function parse4(uri, opts) { + const options = Object.assign({}, opts); + const parsed = { + scheme: void 0, + userinfo: void 0, + host: "", + port: void 0, + path: "", + query: void 0, + fragment: void 0 + }; + let isIP = false; + if (options.reference === "suffix") { + if (options.scheme) { + uri = options.scheme + ":" + uri; + } else { + uri = "//" + uri; + } + } + const matches = uri.match(URI_PARSE); + if (matches) { + parsed.scheme = matches[1]; + parsed.userinfo = matches[3]; + parsed.host = matches[4]; + parsed.port = parseInt(matches[5], 10); + parsed.path = matches[6] || ""; + parsed.query = matches[7]; + parsed.fragment = matches[8]; + if (isNaN(parsed.port)) { + parsed.port = matches[5]; + } + if (parsed.host) { + const ipv4result = isIPv4(parsed.host); + if (ipv4result === false) { + const ipv6result = normalizeIPv6(parsed.host); + parsed.host = ipv6result.host.toLowerCase(); + isIP = ipv6result.isIPV6; + } else { + isIP = true; + } + } + if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) { + parsed.reference = "same-document"; + } else if (parsed.scheme === void 0) { + parsed.reference = "relative"; + } else if (parsed.fragment === void 0) { + parsed.reference = "absolute"; + } else { + parsed.reference = "uri"; + } + if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) { + 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 = URL.domainToASCII(parsed.host.toLowerCase()); + } catch (e) { + parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e; + } + } + } + if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) { + if (uri.indexOf("%") !== -1) { + if (parsed.scheme !== void 0) { + parsed.scheme = unescape(parsed.scheme); + } + if (parsed.host !== void 0) { + parsed.host = unescape(parsed.host); + } + } + if (parsed.path) { + parsed.path = escape(unescape(parsed.path)); + } + if (parsed.fragment) { + parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment)); + } + } + if (schemeHandler && schemeHandler.parse) { + schemeHandler.parse(parsed, options); + } + } else { + parsed.error = parsed.error || "URI can not be parsed."; + } + return parsed; + } + var fastUri = { + SCHEMES, + normalize, + resolve, + resolveComponent, + equal, + serialize, + parse: parse4 + }; + module.exports = fastUri; + module.exports.default = fastUri; + module.exports.fastUri = fastUri; + } +}); + +// node_modules/ajv/dist/runtime/uri.js +var require_uri = __commonJS({ + "node_modules/ajv/dist/runtime/uri.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var uri = require_fast_uri(); + uri.code = 'require("ajv/dist/runtime/uri").default'; + exports.default = uri; + } +}); + +// node_modules/ajv/dist/core.js +var require_core = __commonJS({ + "node_modules/ajv/dist/core.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = void 0; + var validate_1 = require_validate(); + Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() { + return validate_1.KeywordCxt; + } }); + var codegen_1 = require_codegen(); + Object.defineProperty(exports, "_", { enumerable: true, get: function() { + return codegen_1._; + } }); + Object.defineProperty(exports, "str", { enumerable: true, get: function() { + return codegen_1.str; + } }); + Object.defineProperty(exports, "stringify", { enumerable: true, get: function() { + return codegen_1.stringify; + } }); + Object.defineProperty(exports, "nil", { enumerable: true, get: function() { + return codegen_1.nil; + } }); + Object.defineProperty(exports, "Name", { enumerable: true, get: function() { + return codegen_1.Name; + } }); + Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() { + return codegen_1.CodeGen; + } }); + var validation_error_1 = require_validation_error(); + var ref_error_1 = require_ref_error(); + var rules_1 = require_rules(); + var compile_1 = require_compile(); + var codegen_2 = require_codegen(); + var resolve_1 = require_resolve(); + var dataType_1 = require_dataType(); + var util_1 = require_util(); + var $dataRefSchema = require_data(); + var uri_1 = require_uri(); + var defaultRegExp = (str, flags) => new RegExp(str, flags); + defaultRegExp.code = "new RegExp"; + var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"]; + var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([ + "validate", + "serialize", + "parse", + "wrapper", + "root", + "schema", + "keyword", + "pattern", + "formats", + "validate$data", + "func", + "obj", + "Error" + ]); + var removedOptions = { + errorDataPath: "", + format: "`validateFormats: false` can be used instead.", + nullable: '"nullable" keyword is supported by default.', + jsonPointers: "Deprecated jsPropertySyntax can be used instead.", + extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.", + missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.", + processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`", + sourceCode: "Use option `code: {source: true}`", + strictDefaults: "It is default now, see option `strict`.", + strictKeywords: "It is default now, see option `strict`.", + uniqueItems: '"uniqueItems" keyword is always validated.', + unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).", + cache: "Map is used as cache, schema object as key.", + serialize: "Map is used as cache, schema object as key.", + ajvErrors: "It is default now." + }; + var deprecatedOptions = { + ignoreKeywordsWithRef: "", + jsPropertySyntax: "", + unicode: '"minLength"/"maxLength" account for unicode characters by default.' + }; + var MAX_EXPRESSION = 200; + function requiredOptions(o) { + var _a2, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0; + const s = o.strict; + const _optz = (_a2 = o.code) === null || _a2 === void 0 ? void 0 : _a2.optimize; + const optimize = _optz === true || _optz === void 0 ? 1 : _optz || 0; + const regExp = (_c = (_b = o.code) === null || _b === void 0 ? void 0 : _b.regExp) !== null && _c !== void 0 ? _c : defaultRegExp; + const uriResolver = (_d = o.uriResolver) !== null && _d !== void 0 ? _d : uri_1.default; + return { + strictSchema: (_f = (_e = o.strictSchema) !== null && _e !== void 0 ? _e : s) !== null && _f !== void 0 ? _f : true, + strictNumbers: (_h = (_g = o.strictNumbers) !== null && _g !== void 0 ? _g : s) !== null && _h !== void 0 ? _h : true, + strictTypes: (_k = (_j = o.strictTypes) !== null && _j !== void 0 ? _j : s) !== null && _k !== void 0 ? _k : "log", + strictTuples: (_m = (_l = o.strictTuples) !== null && _l !== void 0 ? _l : s) !== null && _m !== void 0 ? _m : "log", + strictRequired: (_p = (_o = o.strictRequired) !== null && _o !== void 0 ? _o : s) !== null && _p !== void 0 ? _p : false, + code: o.code ? { ...o.code, optimize, regExp } : { optimize, regExp }, + loopRequired: (_q = o.loopRequired) !== null && _q !== void 0 ? _q : MAX_EXPRESSION, + loopEnum: (_r = o.loopEnum) !== null && _r !== void 0 ? _r : MAX_EXPRESSION, + meta: (_s = o.meta) !== null && _s !== void 0 ? _s : true, + messages: (_t = o.messages) !== null && _t !== void 0 ? _t : true, + inlineRefs: (_u = o.inlineRefs) !== null && _u !== void 0 ? _u : true, + schemaId: (_v = o.schemaId) !== null && _v !== void 0 ? _v : "$id", + addUsedSchema: (_w = o.addUsedSchema) !== null && _w !== void 0 ? _w : true, + validateSchema: (_x = o.validateSchema) !== null && _x !== void 0 ? _x : true, + validateFormats: (_y = o.validateFormats) !== null && _y !== void 0 ? _y : true, + unicodeRegExp: (_z = o.unicodeRegExp) !== null && _z !== void 0 ? _z : true, + int32range: (_0 = o.int32range) !== null && _0 !== void 0 ? _0 : true, + uriResolver + }; + } + var Ajv2 = class { + constructor(opts = {}) { + this.schemas = {}; + this.refs = {}; + this.formats = {}; + this._compilations = /* @__PURE__ */ new Set(); + this._loading = {}; + this._cache = /* @__PURE__ */ new Map(); + opts = this.opts = { ...opts, ...requiredOptions(opts) }; + const { es5, lines } = this.opts.code; + this.scope = new codegen_2.ValueScope({ scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines }); + this.logger = getLogger(opts.logger); + const formatOpt = opts.validateFormats; + opts.validateFormats = false; + this.RULES = (0, rules_1.getRules)(); + checkOptions.call(this, removedOptions, opts, "NOT SUPPORTED"); + checkOptions.call(this, deprecatedOptions, opts, "DEPRECATED", "warn"); + this._metaOpts = getMetaSchemaOptions.call(this); + if (opts.formats) + addInitialFormats.call(this); + this._addVocabularies(); + this._addDefaultMetaSchema(); + if (opts.keywords) + addInitialKeywords.call(this, opts.keywords); + if (typeof opts.meta == "object") + this.addMetaSchema(opts.meta); + addInitialSchemas.call(this); + opts.validateFormats = formatOpt; + } + _addVocabularies() { + this.addKeyword("$async"); + } + _addDefaultMetaSchema() { + const { $data, meta: meta3, schemaId } = this.opts; + let _dataRefSchema = $dataRefSchema; + if (schemaId === "id") { + _dataRefSchema = { ...$dataRefSchema }; + _dataRefSchema.id = _dataRefSchema.$id; + delete _dataRefSchema.$id; + } + if (meta3 && $data) + this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false); + } + defaultMeta() { + const { meta: meta3, schemaId } = this.opts; + return this.opts.defaultMeta = typeof meta3 == "object" ? meta3[schemaId] || meta3 : void 0; + } + validate(schemaKeyRef, data) { + let v; + if (typeof schemaKeyRef == "string") { + v = this.getSchema(schemaKeyRef); + if (!v) + throw new Error(`no schema with key or ref "${schemaKeyRef}"`); + } else { + v = this.compile(schemaKeyRef); + } + const valid = v(data); + if (!("$async" in v)) + this.errors = v.errors; + return valid; + } + compile(schema, _meta) { + const sch = this._addSchema(schema, _meta); + return sch.validate || this._compileSchemaEnv(sch); + } + compileAsync(schema, meta3) { + if (typeof this.opts.loadSchema != "function") { + throw new Error("options.loadSchema should be a function"); + } + const { loadSchema } = this.opts; + return runCompileAsync.call(this, schema, meta3); + async function runCompileAsync(_schema, _meta) { + await loadMetaSchema.call(this, _schema.$schema); + const sch = this._addSchema(_schema, _meta); + return sch.validate || _compileAsync.call(this, sch); + } + async function loadMetaSchema($ref) { + if ($ref && !this.getSchema($ref)) { + await runCompileAsync.call(this, { $ref }, true); + } + } + async function _compileAsync(sch) { + try { + return this._compileSchemaEnv(sch); + } catch (e) { + if (!(e instanceof ref_error_1.default)) + throw e; + checkLoaded.call(this, e); + await loadMissingSchema.call(this, e.missingSchema); + return _compileAsync.call(this, sch); + } + } + function checkLoaded({ missingSchema: ref, missingRef }) { + if (this.refs[ref]) { + throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`); + } + } + async function loadMissingSchema(ref) { + const _schema = await _loadSchema.call(this, ref); + if (!this.refs[ref]) + await loadMetaSchema.call(this, _schema.$schema); + if (!this.refs[ref]) + this.addSchema(_schema, ref, meta3); + } + async function _loadSchema(ref) { + const p = this._loading[ref]; + if (p) + return p; + try { + return await (this._loading[ref] = loadSchema(ref)); + } finally { + delete this._loading[ref]; + } + } + } + // Adds schema to the instance + addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) { + if (Array.isArray(schema)) { + for (const sch of schema) + this.addSchema(sch, void 0, _meta, _validateSchema); + return this; + } + let id; + if (typeof schema === "object") { + const { schemaId } = this.opts; + id = schema[schemaId]; + if (id !== void 0 && typeof id != "string") { + throw new Error(`schema ${schemaId} must be string`); + } + } + key = (0, resolve_1.normalizeId)(key || id); + this._checkUnique(key); + this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true); + return this; + } + // Add schema that will be used to validate other schemas + // options in META_IGNORE_OPTIONS are alway set to false + addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) { + this.addSchema(schema, key, true, _validateSchema); + return this; + } + // Validate schema against its meta-schema + validateSchema(schema, throwOrLogError) { + if (typeof schema == "boolean") + return true; + let $schema; + $schema = schema.$schema; + if ($schema !== void 0 && typeof $schema != "string") { + throw new Error("$schema must be a string"); + } + $schema = $schema || this.opts.defaultMeta || this.defaultMeta(); + if (!$schema) { + this.logger.warn("meta-schema not available"); + this.errors = null; + return true; + } + const valid = this.validate($schema, schema); + if (!valid && throwOrLogError) { + const message = "schema is invalid: " + this.errorsText(); + if (this.opts.validateSchema === "log") + this.logger.error(message); + else + throw new Error(message); + } + return valid; + } + // Get compiled schema by `key` or `ref`. + // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id) + getSchema(keyRef) { + let sch; + while (typeof (sch = getSchEnv.call(this, keyRef)) == "string") + keyRef = sch; + if (sch === void 0) { + const { schemaId } = this.opts; + const root = new compile_1.SchemaEnv({ schema: {}, schemaId }); + sch = compile_1.resolveSchema.call(this, root, keyRef); + if (!sch) + return; + this.refs[keyRef] = sch; + } + return sch.validate || this._compileSchemaEnv(sch); + } + // Remove cached schema(s). + // If no parameter is passed all schemas but meta-schemas are removed. + // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed. + // Even if schema is referenced by other schemas it still can be removed as other schemas have local references. + removeSchema(schemaKeyRef) { + if (schemaKeyRef instanceof RegExp) { + this._removeAllSchemas(this.schemas, schemaKeyRef); + this._removeAllSchemas(this.refs, schemaKeyRef); + return this; + } + switch (typeof schemaKeyRef) { + case "undefined": + this._removeAllSchemas(this.schemas); + this._removeAllSchemas(this.refs); + this._cache.clear(); + return this; + case "string": { + const sch = getSchEnv.call(this, schemaKeyRef); + if (typeof sch == "object") + this._cache.delete(sch.schema); + delete this.schemas[schemaKeyRef]; + delete this.refs[schemaKeyRef]; + return this; + } + case "object": { + const cacheKey = schemaKeyRef; + this._cache.delete(cacheKey); + let id = schemaKeyRef[this.opts.schemaId]; + if (id) { + id = (0, resolve_1.normalizeId)(id); + delete this.schemas[id]; + delete this.refs[id]; + } + return this; + } + default: + throw new Error("ajv.removeSchema: invalid parameter"); + } + } + // add "vocabulary" - a collection of keywords + addVocabulary(definitions) { + for (const def of definitions) + this.addKeyword(def); + return this; + } + addKeyword(kwdOrDef, def) { + let keyword; + if (typeof kwdOrDef == "string") { + keyword = kwdOrDef; + if (typeof def == "object") { + this.logger.warn("these parameters are deprecated, see docs for addKeyword"); + def.keyword = keyword; + } + } else if (typeof kwdOrDef == "object" && def === void 0) { + def = kwdOrDef; + keyword = def.keyword; + if (Array.isArray(keyword) && !keyword.length) { + throw new Error("addKeywords: keyword must be string or non-empty array"); + } + } else { + throw new Error("invalid addKeywords parameters"); + } + checkKeyword.call(this, keyword, def); + if (!def) { + (0, util_1.eachItem)(keyword, (kwd) => addRule.call(this, kwd)); + return this; + } + keywordMetaschema.call(this, def); + const definition = { + ...def, + type: (0, dataType_1.getJSONTypes)(def.type), + schemaType: (0, dataType_1.getJSONTypes)(def.schemaType) + }; + (0, util_1.eachItem)(keyword, definition.type.length === 0 ? (k) => addRule.call(this, k, definition) : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t))); + return this; + } + getKeyword(keyword) { + const rule = this.RULES.all[keyword]; + return typeof rule == "object" ? rule.definition : !!rule; + } + // Remove keyword + removeKeyword(keyword) { + const { RULES } = this; + delete RULES.keywords[keyword]; + delete RULES.all[keyword]; + for (const group of RULES.rules) { + const i = group.rules.findIndex((rule) => rule.keyword === keyword); + if (i >= 0) + group.rules.splice(i, 1); + } + return this; + } + // Add format + addFormat(name, format) { + if (typeof format == "string") + format = new RegExp(format); + this.formats[name] = format; + return this; + } + errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) { + if (!errors || errors.length === 0) + return "No errors"; + return errors.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg); + } + $dataMetaSchema(metaSchema, keywordsJsonPointers) { + const rules = this.RULES.all; + metaSchema = JSON.parse(JSON.stringify(metaSchema)); + for (const jsonPointer of keywordsJsonPointers) { + const segments = jsonPointer.split("/").slice(1); + let keywords = metaSchema; + for (const seg of segments) + keywords = keywords[seg]; + for (const key in rules) { + const rule = rules[key]; + if (typeof rule != "object") + continue; + const { $data } = rule.definition; + const schema = keywords[key]; + if ($data && schema) + keywords[key] = schemaOrData(schema); + } + } + return metaSchema; + } + _removeAllSchemas(schemas, regex) { + for (const keyRef in schemas) { + const sch = schemas[keyRef]; + if (!regex || regex.test(keyRef)) { + if (typeof sch == "string") { + delete schemas[keyRef]; + } else if (sch && !sch.meta) { + this._cache.delete(sch.schema); + delete schemas[keyRef]; + } + } + } + } + _addSchema(schema, meta3, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) { + let id; + const { schemaId } = this.opts; + if (typeof schema == "object") { + id = schema[schemaId]; + } else { + if (this.opts.jtd) + throw new Error("schema must be object"); + else if (typeof schema != "boolean") + throw new Error("schema must be object or boolean"); + } + let sch = this._cache.get(schema); + if (sch !== void 0) + return sch; + baseId = (0, resolve_1.normalizeId)(id || baseId); + const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId); + sch = new compile_1.SchemaEnv({ schema, schemaId, meta: meta3, baseId, localRefs }); + this._cache.set(sch.schema, sch); + if (addSchema && !baseId.startsWith("#")) { + if (baseId) + this._checkUnique(baseId); + this.refs[baseId] = sch; + } + if (validateSchema) + this.validateSchema(schema, true); + return sch; + } + _checkUnique(id) { + if (this.schemas[id] || this.refs[id]) { + throw new Error(`schema with key or id "${id}" already exists`); + } + } + _compileSchemaEnv(sch) { + if (sch.meta) + this._compileMetaSchema(sch); + else + compile_1.compileSchema.call(this, sch); + if (!sch.validate) + throw new Error("ajv implementation error"); + return sch.validate; + } + _compileMetaSchema(sch) { + const currentOpts = this.opts; + this.opts = this._metaOpts; + try { + compile_1.compileSchema.call(this, sch); + } finally { + this.opts = currentOpts; + } + } + }; + Ajv2.ValidationError = validation_error_1.default; + Ajv2.MissingRefError = ref_error_1.default; + exports.default = Ajv2; + function checkOptions(checkOpts, options, msg, log = "error") { + for (const key in checkOpts) { + const opt = key; + if (opt in options) + this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`); + } + } + function getSchEnv(keyRef) { + keyRef = (0, resolve_1.normalizeId)(keyRef); + return this.schemas[keyRef] || this.refs[keyRef]; + } + function addInitialSchemas() { + const optsSchemas = this.opts.schemas; + if (!optsSchemas) + return; + if (Array.isArray(optsSchemas)) + this.addSchema(optsSchemas); + else + for (const key in optsSchemas) + this.addSchema(optsSchemas[key], key); + } + function addInitialFormats() { + for (const name in this.opts.formats) { + const format = this.opts.formats[name]; + if (format) + this.addFormat(name, format); + } + } + function addInitialKeywords(defs) { + if (Array.isArray(defs)) { + this.addVocabulary(defs); + return; + } + this.logger.warn("keywords option as map is deprecated, pass array"); + for (const keyword in defs) { + const def = defs[keyword]; + if (!def.keyword) + def.keyword = keyword; + this.addKeyword(def); + } + } + function getMetaSchemaOptions() { + const metaOpts = { ...this.opts }; + for (const opt of META_IGNORE_OPTIONS) + delete metaOpts[opt]; + return metaOpts; + } + var noLogs = { log() { + }, warn() { + }, error() { + } }; + function getLogger(logger) { + if (logger === false) + return noLogs; + if (logger === void 0) + return console; + if (logger.log && logger.warn && logger.error) + return logger; + throw new Error("logger must implement log, warn and error methods"); + } + var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i; + function checkKeyword(keyword, def) { + const { RULES } = this; + (0, util_1.eachItem)(keyword, (kwd) => { + if (RULES.keywords[kwd]) + throw new Error(`Keyword ${kwd} is already defined`); + if (!KEYWORD_NAME.test(kwd)) + throw new Error(`Keyword ${kwd} has invalid name`); + }); + if (!def) + return; + if (def.$data && !("code" in def || "validate" in def)) { + throw new Error('$data keyword must have "code" or "validate" function'); + } + } + function addRule(keyword, definition, dataType) { + var _a2; + const post = definition === null || definition === void 0 ? void 0 : definition.post; + if (dataType && post) + throw new Error('keyword with "post" flag cannot have "type"'); + const { RULES } = this; + let ruleGroup = post ? RULES.post : RULES.rules.find(({ type: t }) => t === dataType); + if (!ruleGroup) { + ruleGroup = { type: dataType, rules: [] }; + RULES.rules.push(ruleGroup); + } + RULES.keywords[keyword] = true; + if (!definition) + return; + const rule = { + keyword, + definition: { + ...definition, + type: (0, dataType_1.getJSONTypes)(definition.type), + schemaType: (0, dataType_1.getJSONTypes)(definition.schemaType) + } + }; + if (definition.before) + addBeforeRule.call(this, ruleGroup, rule, definition.before); + else + ruleGroup.rules.push(rule); + RULES.all[keyword] = rule; + (_a2 = definition.implements) === null || _a2 === void 0 ? void 0 : _a2.forEach((kwd) => this.addKeyword(kwd)); + } + function addBeforeRule(ruleGroup, rule, before) { + const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before); + if (i >= 0) { + ruleGroup.rules.splice(i, 0, rule); + } else { + ruleGroup.rules.push(rule); + this.logger.warn(`rule ${before} is not defined`); + } + } + function keywordMetaschema(def) { + let { metaSchema } = def; + if (metaSchema === void 0) + return; + if (def.$data && this.opts.$data) + metaSchema = schemaOrData(metaSchema); + def.validateSchema = this.compile(metaSchema, true); + } + var $dataRef = { + $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" + }; + function schemaOrData(schema) { + return { anyOf: [schema, $dataRef] }; + } + } +}); + +// node_modules/ajv/dist/vocabularies/core/id.js +var require_id = __commonJS({ + "node_modules/ajv/dist/vocabularies/core/id.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var def = { + keyword: "id", + code() { + throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID'); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/core/ref.js +var require_ref = __commonJS({ + "node_modules/ajv/dist/vocabularies/core/ref.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.callRef = exports.getValidate = void 0; + var ref_error_1 = require_ref_error(); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var compile_1 = require_compile(); + var util_1 = require_util(); + var def = { + keyword: "$ref", + schemaType: "string", + code(cxt) { + const { gen, schema: $ref, it } = cxt; + const { baseId, schemaEnv: env2, validateName, opts, self } = it; + const { root } = env2; + if (($ref === "#" || $ref === "#/") && baseId === root.baseId) + return callRootRef(); + const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref); + if (schOrEnv === void 0) + throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref); + if (schOrEnv instanceof compile_1.SchemaEnv) + return callValidate(schOrEnv); + return inlineRefSchema(schOrEnv); + function callRootRef() { + if (env2 === root) + return callRef(cxt, validateName, env2, env2.$async); + const rootName = gen.scopeValue("root", { ref: root }); + return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async); + } + function callValidate(sch) { + const v = getValidate(cxt, sch); + callRef(cxt, v, sch, sch.$async); + } + function inlineRefSchema(sch) { + const schName = gen.scopeValue("schema", opts.code.source === true ? { ref: sch, code: (0, codegen_1.stringify)(sch) } : { ref: sch }); + const valid = gen.name("valid"); + const schCxt = cxt.subschema({ + schema: sch, + dataTypes: [], + schemaPath: codegen_1.nil, + topSchemaRef: schName, + errSchemaPath: $ref + }, valid); + cxt.mergeEvaluated(schCxt); + cxt.ok(valid); + } + } + }; + function getValidate(cxt, sch) { + const { gen } = cxt; + return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`; + } + exports.getValidate = getValidate; + function callRef(cxt, v, sch, $async) { + const { gen, it } = cxt; + const { allErrors, schemaEnv: env2, opts } = it; + const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil; + if ($async) + callAsyncRef(); + else + callSyncRef(); + function callAsyncRef() { + if (!env2.$async) + throw new Error("async schema referenced by sync schema"); + const valid = gen.let("valid"); + gen.try(() => { + gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`); + addEvaluatedFrom(v); + if (!allErrors) + gen.assign(valid, true); + }, (e) => { + gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e)); + addErrorsFrom(e); + if (!allErrors) + gen.assign(valid, false); + }); + cxt.ok(valid); + } + function callSyncRef() { + cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v)); + } + function addErrorsFrom(source) { + const errs = (0, codegen_1._)`${source}.errors`; + gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`); + gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`); + } + function addEvaluatedFrom(source) { + var _a2; + if (!it.opts.unevaluated) + return; + const schEvaluated = (_a2 = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a2 === void 0 ? void 0 : _a2.evaluated; + if (it.props !== true) { + if (schEvaluated && !schEvaluated.dynamicProps) { + if (schEvaluated.props !== void 0) { + it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props); + } + } else { + const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`); + it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name); + } + } + if (it.items !== true) { + if (schEvaluated && !schEvaluated.dynamicItems) { + if (schEvaluated.items !== void 0) { + it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items); + } + } else { + const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`); + it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name); + } + } + } + } + exports.callRef = callRef; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/core/index.js +var require_core2 = __commonJS({ + "node_modules/ajv/dist/vocabularies/core/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var id_1 = require_id(); + var ref_1 = require_ref(); + var core = [ + "$schema", + "$id", + "$defs", + "$vocabulary", + { keyword: "$comment" }, + "definitions", + id_1.default, + ref_1.default + ]; + exports.default = core; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitNumber.js +var require_limitNumber = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitNumber.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var ops = codegen_1.operators; + var KWDs = { + maximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT }, + minimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT }, + exclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE }, + exclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE } + }; + var error2 = { + message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`, + params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}` + }; + var def = { + keyword: Object.keys(KWDs), + type: "number", + schemaType: "number", + $data: true, + error: error2, + code(cxt) { + const { keyword, data, schemaCode } = cxt; + cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/multipleOf.js +var require_multipleOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/multipleOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error2 = { + message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`, + params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}` + }; + var def = { + keyword: "multipleOf", + type: "number", + schemaType: "number", + $data: true, + error: error2, + code(cxt) { + const { gen, data, schemaCode, it } = cxt; + const prec = it.opts.multipleOfPrecision; + const res = gen.let("res"); + const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`; + cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/runtime/ucs2length.js +var require_ucs2length = __commonJS({ + "node_modules/ajv/dist/runtime/ucs2length.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + function ucs2length(str) { + const len = str.length; + let length = 0; + let pos = 0; + let value; + while (pos < len) { + length++; + value = str.charCodeAt(pos++); + if (value >= 55296 && value <= 56319 && pos < len) { + value = str.charCodeAt(pos); + if ((value & 64512) === 56320) + pos++; + } + } + return length; + } + exports.default = ucs2length; + ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default'; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitLength.js +var require_limitLength = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitLength.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var ucs2length_1 = require_ucs2length(); + var error2 = { + message({ keyword, schemaCode }) { + const comp = keyword === "maxLength" ? "more" : "fewer"; + return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`; + }, + params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}` + }; + var def = { + keyword: ["maxLength", "minLength"], + type: "string", + schemaType: "number", + $data: true, + error: error2, + code(cxt) { + const { keyword, data, schemaCode, it } = cxt; + const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT; + const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`; + cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/pattern.js +var require_pattern = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/pattern.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var error2 = { + message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`, + params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}` + }; + var def = { + keyword: "pattern", + type: "string", + schemaType: "string", + $data: true, + error: error2, + code(cxt) { + const { data, $data, schema, schemaCode, it } = cxt; + const u = it.opts.unicodeRegExp ? "u" : ""; + const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema); + cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitProperties.js +var require_limitProperties = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitProperties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error2 = { + message({ keyword, schemaCode }) { + const comp = keyword === "maxProperties" ? "more" : "fewer"; + return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`; + }, + params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}` + }; + var def = { + keyword: ["maxProperties", "minProperties"], + type: "object", + schemaType: "number", + $data: true, + error: error2, + code(cxt) { + const { keyword, data, schemaCode } = cxt; + const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT; + cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/required.js +var require_required = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/required.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error2 = { + message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`, + params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}` + }; + var def = { + keyword: "required", + type: "object", + schemaType: "array", + $data: true, + error: error2, + code(cxt) { + const { gen, schema, schemaCode, data, $data, it } = cxt; + const { opts } = it; + if (!$data && schema.length === 0) + return; + const useLoop = schema.length >= opts.loopRequired; + if (it.allErrors) + allErrorsMode(); + else + exitOnErrorMode(); + if (opts.strictRequired) { + const props = cxt.parentSchema.properties; + const { definedProperties } = cxt.it; + for (const requiredKey of schema) { + if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) { + const schemaPath = it.schemaEnv.baseId + it.errSchemaPath; + const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`; + (0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired); + } + } + } + function allErrorsMode() { + if (useLoop || $data) { + cxt.block$data(codegen_1.nil, loopAllRequired); + } else { + for (const prop of schema) { + (0, code_1.checkReportMissingProp)(cxt, prop); + } + } + } + function exitOnErrorMode() { + const missing = gen.let("missing"); + if (useLoop || $data) { + const valid = gen.let("valid", true); + cxt.block$data(valid, () => loopUntilMissing(missing, valid)); + cxt.ok(valid); + } else { + gen.if((0, code_1.checkMissingProp)(cxt, schema, missing)); + (0, code_1.reportMissingProp)(cxt, missing); + gen.else(); + } + } + function loopAllRequired() { + gen.forOf("prop", schemaCode, (prop) => { + cxt.setParams({ missingProperty: prop }); + gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error()); + }); + } + function loopUntilMissing(missing, valid) { + cxt.setParams({ missingProperty: missing }); + gen.forOf(missing, schemaCode, () => { + gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties)); + gen.if((0, codegen_1.not)(valid), () => { + cxt.error(); + gen.break(); + }); + }, codegen_1.nil); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/limitItems.js +var require_limitItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/limitItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error2 = { + message({ keyword, schemaCode }) { + const comp = keyword === "maxItems" ? "more" : "fewer"; + return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`; + }, + params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}` + }; + var def = { + keyword: ["maxItems", "minItems"], + type: "array", + schemaType: "number", + $data: true, + error: error2, + code(cxt) { + const { keyword, data, schemaCode } = cxt; + const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT; + cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/runtime/equal.js +var require_equal = __commonJS({ + "node_modules/ajv/dist/runtime/equal.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var equal = require_fast_deep_equal(); + equal.code = 'require("ajv/dist/runtime/equal").default'; + exports.default = equal; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/uniqueItems.js +var require_uniqueItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/uniqueItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var dataType_1 = require_dataType(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var equal_1 = require_equal(); + var error2 = { + message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`, + params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}` + }; + var def = { + keyword: "uniqueItems", + type: "array", + schemaType: "boolean", + $data: true, + error: error2, + code(cxt) { + const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt; + if (!$data && !schema) + return; + const valid = gen.let("valid"); + const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : []; + cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`); + cxt.ok(valid); + function validateUniqueItems() { + const i = gen.let("i", (0, codegen_1._)`${data}.length`); + const j = gen.let("j"); + cxt.setParams({ i, j }); + gen.assign(valid, true); + gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j)); + } + function canOptimize() { + return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array"); + } + function loopN(i, j) { + const item = gen.name("item"); + const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong); + const indices = gen.const("indices", (0, codegen_1._)`{}`); + gen.for((0, codegen_1._)`;${i}--;`, () => { + gen.let(item, (0, codegen_1._)`${data}[${i}]`); + gen.if(wrongType, (0, codegen_1._)`continue`); + if (itemTypes.length > 1) + gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`); + gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => { + gen.assign(j, (0, codegen_1._)`${indices}[${item}]`); + cxt.error(); + gen.assign(valid, false).break(); + }).code((0, codegen_1._)`${indices}[${item}] = ${i}`); + }); + } + function loopN2(i, j) { + const eql = (0, util_1.useFunc)(gen, equal_1.default); + const outer = gen.name("outer"); + gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => { + cxt.error(); + gen.assign(valid, false).break(outer); + }))); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/const.js +var require_const = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/const.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var equal_1 = require_equal(); + var error2 = { + message: "must be equal to constant", + params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}` + }; + var def = { + keyword: "const", + $data: true, + error: error2, + code(cxt) { + const { gen, data, $data, schemaCode, schema } = cxt; + if ($data || schema && typeof schema == "object") { + cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`); + } else { + cxt.fail((0, codegen_1._)`${schema} !== ${data}`); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/enum.js +var require_enum = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/enum.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var equal_1 = require_equal(); + var error2 = { + message: "must be equal to one of the allowed values", + params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}` + }; + var def = { + keyword: "enum", + schemaType: "array", + $data: true, + error: error2, + code(cxt) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + if (!$data && schema.length === 0) + throw new Error("enum must have non-empty array"); + const useLoop = schema.length >= it.opts.loopEnum; + let eql; + const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default); + let valid; + if (useLoop || $data) { + valid = gen.let("valid"); + cxt.block$data(valid, loopEnum); + } else { + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const vSchema = gen.const("vSchema", schemaCode); + valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i))); + } + cxt.pass(valid); + function loopEnum() { + gen.assign(valid, false); + gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break())); + } + function equalCode(vSchema, i) { + const sch = schema[i]; + return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`; + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/validation/index.js +var require_validation2 = __commonJS({ + "node_modules/ajv/dist/vocabularies/validation/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var limitNumber_1 = require_limitNumber(); + var multipleOf_1 = require_multipleOf(); + var limitLength_1 = require_limitLength(); + var pattern_1 = require_pattern(); + var limitProperties_1 = require_limitProperties(); + var required_1 = require_required(); + var limitItems_1 = require_limitItems(); + var uniqueItems_1 = require_uniqueItems(); + var const_1 = require_const(); + var enum_1 = require_enum(); + var validation = [ + // number + limitNumber_1.default, + multipleOf_1.default, + // string + limitLength_1.default, + pattern_1.default, + // object + limitProperties_1.default, + required_1.default, + // array + limitItems_1.default, + uniqueItems_1.default, + // any + { keyword: "type", schemaType: ["string", "array"] }, + { keyword: "nullable", schemaType: "boolean" }, + const_1.default, + enum_1.default + ]; + exports.default = validation; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/additionalItems.js +var require_additionalItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/additionalItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateAdditionalItems = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error2 = { + message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`, + params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}` + }; + var def = { + keyword: "additionalItems", + type: "array", + schemaType: ["boolean", "object"], + before: "uniqueItems", + error: error2, + code(cxt) { + const { parentSchema, it } = cxt; + const { items } = parentSchema; + if (!Array.isArray(items)) { + (0, util_1.checkStrictMode)(it, '"additionalItems" is ignored when "items" is not an array of schemas'); + return; + } + validateAdditionalItems(cxt, items); + } + }; + function validateAdditionalItems(cxt, items) { + const { gen, schema, data, keyword, it } = cxt; + it.items = true; + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + if (schema === false) { + cxt.setParams({ len: items.length }); + cxt.pass((0, codegen_1._)`${len} <= ${items.length}`); + } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) { + const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`); + gen.if((0, codegen_1.not)(valid), () => validateItems(valid)); + cxt.ok(valid); + } + function validateItems(valid) { + gen.forRange("i", items.length, len, (i) => { + cxt.subschema({ keyword, dataProp: i, dataPropType: util_1.Type.Num }, valid); + if (!it.allErrors) + gen.if((0, codegen_1.not)(valid), () => gen.break()); + }); + } + } + exports.validateAdditionalItems = validateAdditionalItems; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/items.js +var require_items = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/items.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateTuple = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var code_1 = require_code2(); + var def = { + keyword: "items", + type: "array", + schemaType: ["object", "array", "boolean"], + before: "uniqueItems", + code(cxt) { + const { schema, it } = cxt; + if (Array.isArray(schema)) + return validateTuple(cxt, "additionalItems", schema); + it.items = true; + if ((0, util_1.alwaysValidSchema)(it, schema)) + return; + cxt.ok((0, code_1.validateArray)(cxt)); + } + }; + function validateTuple(cxt, extraItems, schArr = cxt.schema) { + const { gen, parentSchema, data, keyword, it } = cxt; + checkStrictTuple(parentSchema); + if (it.opts.unevaluated && schArr.length && it.items !== true) { + it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items); + } + const valid = gen.name("valid"); + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + schArr.forEach((sch, i) => { + if ((0, util_1.alwaysValidSchema)(it, sch)) + return; + gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({ + keyword, + schemaProp: i, + dataProp: i + }, valid)); + cxt.ok(valid); + }); + function checkStrictTuple(sch) { + const { opts, errSchemaPath } = it; + const l = schArr.length; + const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false); + if (opts.strictTuples && !fullTuple) { + const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`; + (0, util_1.checkStrictMode)(it, msg, opts.strictTuples); + } + } + } + exports.validateTuple = validateTuple; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/prefixItems.js +var require_prefixItems = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/prefixItems.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var items_1 = require_items(); + var def = { + keyword: "prefixItems", + type: "array", + schemaType: ["array"], + before: "uniqueItems", + code: (cxt) => (0, items_1.validateTuple)(cxt, "items") + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/items2020.js +var require_items2020 = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/items2020.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var code_1 = require_code2(); + var additionalItems_1 = require_additionalItems(); + var error2 = { + message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`, + params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}` + }; + var def = { + keyword: "items", + type: "array", + schemaType: ["object", "boolean"], + before: "uniqueItems", + error: error2, + code(cxt) { + const { schema, parentSchema, it } = cxt; + const { prefixItems } = parentSchema; + it.items = true; + if ((0, util_1.alwaysValidSchema)(it, schema)) + return; + if (prefixItems) + (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems); + else + cxt.ok((0, code_1.validateArray)(cxt)); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/contains.js +var require_contains = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/contains.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error2 = { + message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`, + params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}` + }; + var def = { + keyword: "contains", + type: "array", + schemaType: ["object", "boolean"], + before: "uniqueItems", + trackErrors: true, + error: error2, + code(cxt) { + const { gen, schema, parentSchema, data, it } = cxt; + let min; + let max; + const { minContains, maxContains } = parentSchema; + if (it.opts.next) { + min = minContains === void 0 ? 1 : minContains; + max = maxContains; + } else { + min = 1; + } + const len = gen.const("len", (0, codegen_1._)`${data}.length`); + cxt.setParams({ min, max }); + if (max === void 0 && min === 0) { + (0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`); + return; + } + if (max !== void 0 && min > max) { + (0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`); + cxt.fail(); + return; + } + if ((0, util_1.alwaysValidSchema)(it, schema)) { + let cond = (0, codegen_1._)`${len} >= ${min}`; + if (max !== void 0) + cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`; + cxt.pass(cond); + return; + } + it.items = true; + const valid = gen.name("valid"); + if (max === void 0 && min === 1) { + validateItems(valid, () => gen.if(valid, () => gen.break())); + } else if (min === 0) { + gen.let(valid, true); + if (max !== void 0) + gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount); + } else { + gen.let(valid, false); + validateItemsWithCount(); + } + cxt.result(valid, () => cxt.reset()); + function validateItemsWithCount() { + const schValid = gen.name("_valid"); + const count = gen.let("count", 0); + validateItems(schValid, () => gen.if(schValid, () => checkLimits(count))); + } + function validateItems(_valid, block) { + gen.forRange("i", 0, len, (i) => { + cxt.subschema({ + keyword: "contains", + dataProp: i, + dataPropType: util_1.Type.Num, + compositeRule: true + }, _valid); + block(); + }); + } + function checkLimits(count) { + gen.code((0, codegen_1._)`${count}++`); + if (max === void 0) { + gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break()); + } else { + gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break()); + if (min === 1) + gen.assign(valid, true); + else + gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true)); + } + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/dependencies.js +var require_dependencies = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/dependencies.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0; + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var code_1 = require_code2(); + exports.error = { + message: ({ params: { property, depsCount, deps } }) => { + const property_ies = depsCount === 1 ? "property" : "properties"; + return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`; + }, + params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property}, + missingProperty: ${missingProperty}, + depsCount: ${depsCount}, + deps: ${deps}}` + // TODO change to reference + }; + var def = { + keyword: "dependencies", + type: "object", + schemaType: "object", + error: exports.error, + code(cxt) { + const [propDeps, schDeps] = splitDependencies(cxt); + validatePropertyDeps(cxt, propDeps); + validateSchemaDeps(cxt, schDeps); + } + }; + function splitDependencies({ schema }) { + const propertyDeps = {}; + const schemaDeps = {}; + for (const key in schema) { + if (key === "__proto__") + continue; + const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps; + deps[key] = schema[key]; + } + return [propertyDeps, schemaDeps]; + } + function validatePropertyDeps(cxt, propertyDeps = cxt.schema) { + const { gen, data, it } = cxt; + if (Object.keys(propertyDeps).length === 0) + return; + const missing = gen.let("missing"); + for (const prop in propertyDeps) { + const deps = propertyDeps[prop]; + if (deps.length === 0) + continue; + const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties); + cxt.setParams({ + property: prop, + depsCount: deps.length, + deps: deps.join(", ") + }); + if (it.allErrors) { + gen.if(hasProperty, () => { + for (const depProp of deps) { + (0, code_1.checkReportMissingProp)(cxt, depProp); + } + }); + } else { + gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`); + (0, code_1.reportMissingProp)(cxt, missing); + gen.else(); + } + } + } + exports.validatePropertyDeps = validatePropertyDeps; + function validateSchemaDeps(cxt, schemaDeps = cxt.schema) { + const { gen, data, keyword, it } = cxt; + const valid = gen.name("valid"); + for (const prop in schemaDeps) { + if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) + continue; + gen.if( + (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), + () => { + const schCxt = cxt.subschema({ keyword, schemaProp: prop }, valid); + cxt.mergeValidEvaluated(schCxt, valid); + }, + () => gen.var(valid, true) + // TODO var + ); + cxt.ok(valid); + } + } + exports.validateSchemaDeps = validateSchemaDeps; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/propertyNames.js +var require_propertyNames = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/propertyNames.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error2 = { + message: "property name must be valid", + params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}` + }; + var def = { + keyword: "propertyNames", + type: "object", + schemaType: ["object", "boolean"], + error: error2, + code(cxt) { + const { gen, schema, data, it } = cxt; + if ((0, util_1.alwaysValidSchema)(it, schema)) + return; + const valid = gen.name("valid"); + gen.forIn("key", data, (key) => { + cxt.setParams({ propertyName: key }); + cxt.subschema({ + keyword: "propertyNames", + data: key, + dataTypes: ["string"], + propertyName: key, + compositeRule: true + }, valid); + gen.if((0, codegen_1.not)(valid), () => { + cxt.error(true); + if (!it.allErrors) + gen.break(); + }); + }); + cxt.ok(valid); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js +var require_additionalProperties = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var names_1 = require_names(); + var util_1 = require_util(); + var error2 = { + message: "must NOT have additional properties", + params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}` + }; + var def = { + keyword: "additionalProperties", + type: ["object"], + schemaType: ["boolean", "object"], + allowUndefined: true, + trackErrors: true, + error: error2, + code(cxt) { + const { gen, schema, parentSchema, data, errsCount, it } = cxt; + if (!errsCount) + throw new Error("ajv implementation error"); + const { allErrors, opts } = it; + it.props = true; + if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema)) + return; + const props = (0, code_1.allSchemaProperties)(parentSchema.properties); + const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties); + checkAdditionalProperties(); + cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`); + function checkAdditionalProperties() { + gen.forIn("key", data, (key) => { + if (!props.length && !patProps.length) + additionalPropertyCode(key); + else + gen.if(isAdditional(key), () => additionalPropertyCode(key)); + }); + } + function isAdditional(key) { + let definedProp; + if (props.length > 8) { + const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties"); + definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key); + } else if (props.length) { + definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`)); + } else { + definedProp = codegen_1.nil; + } + if (patProps.length) { + definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`)); + } + return (0, codegen_1.not)(definedProp); + } + function deleteAdditional(key) { + gen.code((0, codegen_1._)`delete ${data}[${key}]`); + } + function additionalPropertyCode(key) { + if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) { + deleteAdditional(key); + return; + } + if (schema === false) { + cxt.setParams({ additionalProperty: key }); + cxt.error(); + if (!allErrors) + gen.break(); + return; + } + if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) { + const valid = gen.name("valid"); + if (opts.removeAdditional === "failing") { + applyAdditionalSchema(key, valid, false); + gen.if((0, codegen_1.not)(valid), () => { + cxt.reset(); + deleteAdditional(key); + }); + } else { + applyAdditionalSchema(key, valid); + if (!allErrors) + gen.if((0, codegen_1.not)(valid), () => gen.break()); + } + } + } + function applyAdditionalSchema(key, valid, errors) { + const subschema = { + keyword: "additionalProperties", + dataProp: key, + dataPropType: util_1.Type.Str + }; + if (errors === false) { + Object.assign(subschema, { + compositeRule: true, + createErrors: false, + allErrors: false + }); + } + cxt.subschema(subschema, valid); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/properties.js +var require_properties = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/properties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var validate_1 = require_validate(); + var code_1 = require_code2(); + var util_1 = require_util(); + var additionalProperties_1 = require_additionalProperties(); + var def = { + keyword: "properties", + type: "object", + schemaType: "object", + code(cxt) { + const { gen, schema, parentSchema, data, it } = cxt; + if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) { + additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties")); + } + const allProps = (0, code_1.allSchemaProperties)(schema); + for (const prop of allProps) { + it.definedProperties.add(prop); + } + if (it.opts.unevaluated && allProps.length && it.props !== true) { + it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props); + } + const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p])); + if (properties.length === 0) + return; + const valid = gen.name("valid"); + for (const prop of properties) { + if (hasDefault(prop)) { + applyPropertySchema(prop); + } else { + gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties)); + applyPropertySchema(prop); + if (!it.allErrors) + gen.else().var(valid, true); + gen.endIf(); + } + cxt.it.definedProperties.add(prop); + cxt.ok(valid); + } + function hasDefault(prop) { + return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0; + } + function applyPropertySchema(prop) { + cxt.subschema({ + keyword: "properties", + schemaProp: prop, + dataProp: prop + }, valid); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/patternProperties.js +var require_patternProperties = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/patternProperties.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var util_2 = require_util(); + var def = { + keyword: "patternProperties", + type: "object", + schemaType: "object", + code(cxt) { + const { gen, schema, data, parentSchema, it } = cxt; + const { opts } = it; + const patterns = (0, code_1.allSchemaProperties)(schema); + const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p])); + if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) { + return; + } + const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties; + const valid = gen.name("valid"); + if (it.props !== true && !(it.props instanceof codegen_1.Name)) { + it.props = (0, util_2.evaluatedPropsToName)(gen, it.props); + } + const { props } = it; + validatePatternProperties(); + function validatePatternProperties() { + for (const pat of patterns) { + if (checkProperties) + checkMatchingProperties(pat); + if (it.allErrors) { + validateProperties(pat); + } else { + gen.var(valid, true); + validateProperties(pat); + gen.if(valid); + } + } + } + function checkMatchingProperties(pat) { + for (const prop in checkProperties) { + if (new RegExp(pat).test(prop)) { + (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`); + } + } + } + function validateProperties(pat) { + gen.forIn("key", data, (key) => { + gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => { + const alwaysValid = alwaysValidPatterns.includes(pat); + if (!alwaysValid) { + cxt.subschema({ + keyword: "patternProperties", + schemaProp: pat, + dataProp: key, + dataPropType: util_2.Type.Str + }, valid); + } + if (it.opts.unevaluated && props !== true) { + gen.assign((0, codegen_1._)`${props}[${key}]`, true); + } else if (!alwaysValid && !it.allErrors) { + gen.if((0, codegen_1.not)(valid), () => gen.break()); + } + }); + }); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/not.js +var require_not = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/not.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util(); + var def = { + keyword: "not", + schemaType: ["object", "boolean"], + trackErrors: true, + code(cxt) { + const { gen, schema, it } = cxt; + if ((0, util_1.alwaysValidSchema)(it, schema)) { + cxt.fail(); + return; + } + const valid = gen.name("valid"); + cxt.subschema({ + keyword: "not", + compositeRule: true, + createErrors: false, + allErrors: false + }, valid); + cxt.failResult(valid, () => cxt.reset(), () => cxt.error()); + }, + error: { message: "must NOT be valid" } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/anyOf.js +var require_anyOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/anyOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var code_1 = require_code2(); + var def = { + keyword: "anyOf", + schemaType: "array", + trackErrors: true, + code: code_1.validateUnion, + error: { message: "must match a schema in anyOf" } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/oneOf.js +var require_oneOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/oneOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error2 = { + message: "must match exactly one schema in oneOf", + params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}` + }; + var def = { + keyword: "oneOf", + schemaType: "array", + trackErrors: true, + error: error2, + code(cxt) { + const { gen, schema, parentSchema, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + if (it.opts.discriminator && parentSchema.discriminator) + return; + const schArr = schema; + const valid = gen.let("valid", false); + const passing = gen.let("passing", null); + const schValid = gen.name("_valid"); + cxt.setParams({ passing }); + gen.block(validateOneOf); + cxt.result(valid, () => cxt.reset(), () => cxt.error(true)); + function validateOneOf() { + schArr.forEach((sch, i) => { + let schCxt; + if ((0, util_1.alwaysValidSchema)(it, sch)) { + gen.var(schValid, true); + } else { + schCxt = cxt.subschema({ + keyword: "oneOf", + schemaProp: i, + compositeRule: true + }, schValid); + } + if (i > 0) { + gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else(); + } + gen.if(schValid, () => { + gen.assign(valid, true); + gen.assign(passing, i); + if (schCxt) + cxt.mergeEvaluated(schCxt, codegen_1.Name); + }); + }); + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/allOf.js +var require_allOf = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/allOf.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util(); + var def = { + keyword: "allOf", + schemaType: "array", + code(cxt) { + const { gen, schema, it } = cxt; + if (!Array.isArray(schema)) + throw new Error("ajv implementation error"); + const valid = gen.name("valid"); + schema.forEach((sch, i) => { + if ((0, util_1.alwaysValidSchema)(it, sch)) + return; + const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid); + cxt.ok(valid); + cxt.mergeEvaluated(schCxt); + }); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/if.js +var require_if = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/if.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var util_1 = require_util(); + var error2 = { + message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`, + params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}` + }; + var def = { + keyword: "if", + schemaType: ["object", "boolean"], + trackErrors: true, + error: error2, + code(cxt) { + const { gen, parentSchema, it } = cxt; + if (parentSchema.then === void 0 && parentSchema.else === void 0) { + (0, util_1.checkStrictMode)(it, '"if" without "then" and "else" is ignored'); + } + const hasThen = hasSchema(it, "then"); + const hasElse = hasSchema(it, "else"); + if (!hasThen && !hasElse) + return; + const valid = gen.let("valid", true); + const schValid = gen.name("_valid"); + validateIf(); + cxt.reset(); + if (hasThen && hasElse) { + const ifClause = gen.let("ifClause"); + cxt.setParams({ ifClause }); + gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause)); + } else if (hasThen) { + gen.if(schValid, validateClause("then")); + } else { + gen.if((0, codegen_1.not)(schValid), validateClause("else")); + } + cxt.pass(valid, () => cxt.error(true)); + function validateIf() { + const schCxt = cxt.subschema({ + keyword: "if", + compositeRule: true, + createErrors: false, + allErrors: false + }, schValid); + cxt.mergeEvaluated(schCxt); + } + function validateClause(keyword, ifClause) { + return () => { + const schCxt = cxt.subschema({ keyword }, schValid); + gen.assign(valid, schValid); + cxt.mergeValidEvaluated(schCxt, valid); + if (ifClause) + gen.assign(ifClause, (0, codegen_1._)`${keyword}`); + else + cxt.setParams({ ifClause: keyword }); + }; + } + } + }; + function hasSchema(it, keyword) { + const schema = it.schema[keyword]; + return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema); + } + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/thenElse.js +var require_thenElse = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/thenElse.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var util_1 = require_util(); + var def = { + keyword: ["then", "else"], + schemaType: ["object", "boolean"], + code({ keyword, parentSchema, it }) { + if (parentSchema.if === void 0) + (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`); + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/applicator/index.js +var require_applicator = __commonJS({ + "node_modules/ajv/dist/vocabularies/applicator/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var additionalItems_1 = require_additionalItems(); + var prefixItems_1 = require_prefixItems(); + var items_1 = require_items(); + var items2020_1 = require_items2020(); + var contains_1 = require_contains(); + var dependencies_1 = require_dependencies(); + var propertyNames_1 = require_propertyNames(); + var additionalProperties_1 = require_additionalProperties(); + var properties_1 = require_properties(); + var patternProperties_1 = require_patternProperties(); + var not_1 = require_not(); + var anyOf_1 = require_anyOf(); + var oneOf_1 = require_oneOf(); + var allOf_1 = require_allOf(); + var if_1 = require_if(); + var thenElse_1 = require_thenElse(); + function getApplicator(draft2020 = false) { + const applicator = [ + // any + not_1.default, + anyOf_1.default, + oneOf_1.default, + allOf_1.default, + if_1.default, + thenElse_1.default, + // object + propertyNames_1.default, + additionalProperties_1.default, + dependencies_1.default, + properties_1.default, + patternProperties_1.default + ]; + if (draft2020) + applicator.push(prefixItems_1.default, items2020_1.default); + else + applicator.push(additionalItems_1.default, items_1.default); + applicator.push(contains_1.default); + return applicator; + } + exports.default = getApplicator; + } +}); + +// node_modules/ajv/dist/vocabularies/format/format.js +var require_format = __commonJS({ + "node_modules/ajv/dist/vocabularies/format/format.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var error2 = { + message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`, + params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}` + }; + var def = { + keyword: "format", + type: ["number", "string"], + schemaType: "string", + $data: true, + error: error2, + code(cxt, ruleType) { + const { gen, data, $data, schema, schemaCode, it } = cxt; + const { opts, errSchemaPath, schemaEnv, self } = it; + if (!opts.validateFormats) + return; + if ($data) + validate$DataFormat(); + else + validateFormat(); + function validate$DataFormat() { + const fmts = gen.scopeValue("formats", { + ref: self.formats, + code: opts.code.formats + }); + const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`); + const fType = gen.let("fType"); + 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} && !${format}`; + } + function invalidFmt() { + 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() { + const formatDef = self.formats[schema]; + if (!formatDef) { + unknownFormat(); + return; + } + if (formatDef === true) + return; + const [fmtType, format, fmtRef] = getFormat(formatDef); + if (fmtType === ruleType) + cxt.pass(validCondition()); + function unknownFormat() { + if (opts.strictSchema === false) { + self.logger.warn(unknownMsg()); + return; + } + throw new Error(unknownMsg()); + function unknownMsg() { + return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`; + } + } + function getFormat(fmtDef) { + const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0; + const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code }); + if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) { + return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`]; + } + return ["string", fmtDef, fmt]; + } + function validCondition() { + if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) { + if (!schemaEnv.$async) + throw new Error("async format in sync schema"); + return (0, codegen_1._)`await ${fmtRef}(${data})`; + } + return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`; + } + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/vocabularies/format/index.js +var require_format2 = __commonJS({ + "node_modules/ajv/dist/vocabularies/format/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var format_1 = require_format(); + var format = [format_1.default]; + exports.default = format; + } +}); + +// node_modules/ajv/dist/vocabularies/metadata.js +var require_metadata = __commonJS({ + "node_modules/ajv/dist/vocabularies/metadata.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.contentVocabulary = exports.metadataVocabulary = void 0; + exports.metadataVocabulary = [ + "title", + "description", + "default", + "deprecated", + "readOnly", + "writeOnly", + "examples" + ]; + exports.contentVocabulary = [ + "contentMediaType", + "contentEncoding", + "contentSchema" + ]; + } +}); + +// node_modules/ajv/dist/vocabularies/draft7.js +var require_draft7 = __commonJS({ + "node_modules/ajv/dist/vocabularies/draft7.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var core_1 = require_core2(); + var validation_1 = require_validation2(); + var applicator_1 = require_applicator(); + var format_1 = require_format2(); + var metadata_1 = require_metadata(); + var draft7Vocabularies = [ + core_1.default, + validation_1.default, + (0, applicator_1.default)(), + format_1.default, + metadata_1.metadataVocabulary, + metadata_1.contentVocabulary + ]; + exports.default = draft7Vocabularies; + } +}); + +// node_modules/ajv/dist/vocabularies/discriminator/types.js +var require_types = __commonJS({ + "node_modules/ajv/dist/vocabularies/discriminator/types.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.DiscrError = void 0; + var DiscrError; + (function(DiscrError2) { + DiscrError2["Tag"] = "tag"; + DiscrError2["Mapping"] = "mapping"; + })(DiscrError || (exports.DiscrError = DiscrError = {})); + } +}); + +// node_modules/ajv/dist/vocabularies/discriminator/index.js +var require_discriminator = __commonJS({ + "node_modules/ajv/dist/vocabularies/discriminator/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var codegen_1 = require_codegen(); + var types_1 = require_types(); + var compile_1 = require_compile(); + var ref_error_1 = require_ref_error(); + var util_1 = require_util(); + var error2 = { + message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`, + params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}` + }; + var def = { + keyword: "discriminator", + type: "object", + schemaType: "object", + error: error2, + code(cxt) { + const { gen, data, schema, parentSchema, it } = cxt; + const { oneOf } = parentSchema; + if (!it.opts.discriminator) { + throw new Error("discriminator: requires discriminator option"); + } + const tagName = schema.propertyName; + if (typeof tagName != "string") + throw new Error("discriminator: requires propertyName"); + if (schema.mapping) + throw new Error("discriminator: mapping is not supported"); + if (!oneOf) + throw new Error("discriminator: requires oneOf keyword"); + const valid = gen.let("valid", false); + const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`); + gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, { discrError: types_1.DiscrError.Tag, tag, tagName })); + cxt.ok(valid); + function validateMapping() { + const mapping = getMapping(); + gen.if(false); + for (const tagValue in mapping) { + gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`); + gen.assign(valid, applyTagSchema(mapping[tagValue])); + } + gen.else(); + cxt.error(false, { discrError: types_1.DiscrError.Mapping, tag, tagName }); + gen.endIf(); + } + function applyTagSchema(schemaProp) { + const _valid = gen.name("valid"); + const schCxt = cxt.subschema({ keyword: "oneOf", schemaProp }, _valid); + cxt.mergeEvaluated(schCxt, codegen_1.Name); + return _valid; + } + function getMapping() { + var _a2; + const oneOfMapping = {}; + const topRequired = hasRequired(parentSchema); + let tagRequired = true; + for (let i = 0; i < oneOf.length; i++) { + let sch = oneOf[i]; + if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) { + const ref = sch.$ref; + sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref); + if (sch instanceof compile_1.SchemaEnv) + sch = sch.schema; + if (sch === void 0) + throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref); + } + const propSch = (_a2 = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a2 === void 0 ? void 0 : _a2[tagName]; + if (typeof propSch != "object") { + throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`); + } + tagRequired = tagRequired && (topRequired || hasRequired(sch)); + addMappings(propSch, i); + } + if (!tagRequired) + throw new Error(`discriminator: "${tagName}" must be required`); + return oneOfMapping; + function hasRequired({ required: required2 }) { + return Array.isArray(required2) && required2.includes(tagName); + } + function addMappings(sch, i) { + if (sch.const) { + addMapping(sch.const, i); + } else if (sch.enum) { + for (const tagValue of sch.enum) { + addMapping(tagValue, i); + } + } else { + throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`); + } + } + function addMapping(tagValue, i) { + if (typeof tagValue != "string" || tagValue in oneOfMapping) { + throw new Error(`discriminator: "${tagName}" values must be unique strings`); + } + oneOfMapping[tagValue] = i; + } + } + } + }; + exports.default = def; + } +}); + +// node_modules/ajv/dist/refs/json-schema-draft-07.json +var require_json_schema_draft_07 = __commonJS({ + "node_modules/ajv/dist/refs/json-schema-draft-07.json"(exports, module) { + module.exports = { + $schema: "http://json-schema.org/draft-07/schema#", + $id: "http://json-schema.org/draft-07/schema#", + title: "Core schema meta-schema", + definitions: { + schemaArray: { + type: "array", + minItems: 1, + items: { $ref: "#" } + }, + nonNegativeInteger: { + type: "integer", + minimum: 0 + }, + nonNegativeIntegerDefault0: { + allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }] + }, + simpleTypes: { + enum: ["array", "boolean", "integer", "null", "number", "object", "string"] + }, + stringArray: { + type: "array", + items: { type: "string" }, + uniqueItems: true, + default: [] + } + }, + type: ["object", "boolean"], + properties: { + $id: { + type: "string", + format: "uri-reference" + }, + $schema: { + type: "string", + format: "uri" + }, + $ref: { + type: "string", + format: "uri-reference" + }, + $comment: { + type: "string" + }, + title: { + type: "string" + }, + description: { + type: "string" + }, + default: true, + readOnly: { + type: "boolean", + default: false + }, + examples: { + type: "array", + items: true + }, + multipleOf: { + type: "number", + exclusiveMinimum: 0 + }, + maximum: { + type: "number" + }, + exclusiveMaximum: { + type: "number" + }, + minimum: { + type: "number" + }, + exclusiveMinimum: { + type: "number" + }, + maxLength: { $ref: "#/definitions/nonNegativeInteger" }, + minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, + pattern: { + type: "string", + format: "regex" + }, + additionalItems: { $ref: "#" }, + items: { + anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }], + default: true + }, + maxItems: { $ref: "#/definitions/nonNegativeInteger" }, + minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, + uniqueItems: { + type: "boolean", + default: false + }, + contains: { $ref: "#" }, + maxProperties: { $ref: "#/definitions/nonNegativeInteger" }, + minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" }, + required: { $ref: "#/definitions/stringArray" }, + additionalProperties: { $ref: "#" }, + definitions: { + type: "object", + additionalProperties: { $ref: "#" }, + default: {} + }, + properties: { + type: "object", + additionalProperties: { $ref: "#" }, + default: {} + }, + patternProperties: { + type: "object", + additionalProperties: { $ref: "#" }, + propertyNames: { format: "regex" }, + default: {} + }, + dependencies: { + type: "object", + additionalProperties: { + anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }] + } + }, + propertyNames: { $ref: "#" }, + const: true, + enum: { + type: "array", + items: true, + minItems: 1, + uniqueItems: true + }, + type: { + anyOf: [ + { $ref: "#/definitions/simpleTypes" }, + { + type: "array", + items: { $ref: "#/definitions/simpleTypes" }, + minItems: 1, + uniqueItems: true + } + ] + }, + format: { type: "string" }, + contentMediaType: { type: "string" }, + contentEncoding: { type: "string" }, + if: { $ref: "#" }, + then: { $ref: "#" }, + else: { $ref: "#" }, + allOf: { $ref: "#/definitions/schemaArray" }, + anyOf: { $ref: "#/definitions/schemaArray" }, + oneOf: { $ref: "#/definitions/schemaArray" }, + not: { $ref: "#" } + }, + default: true + }; + } +}); + +// node_modules/ajv/dist/ajv.js +var require_ajv = __commonJS({ + "node_modules/ajv/dist/ajv.js"(exports, module) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv = void 0; + var core_1 = require_core(); + var draft7_1 = require_draft7(); + var discriminator_1 = require_discriminator(); + var draft7MetaSchema = require_json_schema_draft_07(); + var META_SUPPORT_DATA = ["/properties"]; + var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema"; + var Ajv2 = class extends core_1.default { + _addVocabularies() { + super._addVocabularies(); + draft7_1.default.forEach((v) => this.addVocabulary(v)); + if (this.opts.discriminator) + this.addKeyword(discriminator_1.default); + } + _addDefaultMetaSchema() { + super._addDefaultMetaSchema(); + if (!this.opts.meta) + return; + const metaSchema = this.opts.$data ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA) : draft7MetaSchema; + this.addMetaSchema(metaSchema, META_SCHEMA_ID, false); + this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID; + } + defaultMeta() { + return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0); + } + }; + exports.Ajv = Ajv2; + module.exports = exports = Ajv2; + module.exports.Ajv = Ajv2; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = Ajv2; + var validate_1 = require_validate(); + Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() { + return validate_1.KeywordCxt; + } }); + var codegen_1 = require_codegen(); + Object.defineProperty(exports, "_", { enumerable: true, get: function() { + return codegen_1._; + } }); + Object.defineProperty(exports, "str", { enumerable: true, get: function() { + return codegen_1.str; + } }); + Object.defineProperty(exports, "stringify", { enumerable: true, get: function() { + return codegen_1.stringify; + } }); + Object.defineProperty(exports, "nil", { enumerable: true, get: function() { + return codegen_1.nil; + } }); + Object.defineProperty(exports, "Name", { enumerable: true, get: function() { + return codegen_1.Name; + } }); + Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() { + return codegen_1.CodeGen; + } }); + var validation_error_1 = require_validation_error(); + Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() { + return validation_error_1.default; + } }); + var ref_error_1 = require_ref_error(); + Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() { + return ref_error_1.default; + } }); + } +}); + +// node_modules/ajv-formats/dist/formats.js +var require_formats = __commonJS({ + "node_modules/ajv-formats/dist/formats.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.formatNames = exports.fastFormats = exports.fullFormats = void 0; + function fmtDef(validate, compare) { + return { validate, compare }; + } + exports.fullFormats = { + // date: http://tools.ietf.org/html/rfc3339#section-5.6 + 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), + "iso-time": fmtDef(getTime(), compareIsoTime), + "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, + "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, + // For the source: https://gist.github.com/dperini/729294 + // For test cases: https://mathiasbynens.be/demo/url-regex + url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|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-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu, + email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, + 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, + // 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, + // 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 + // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A + "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/, + "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i, + // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00 + "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/, + // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types + // byte: https://github.com/miguelmota/is-base64 + byte, + // signed 32 bit integer + int32: { type: "number", validate: validateInt32 }, + // signed 64 bit integer + int64: { type: "number", validate: validateInt64 }, + // C-type float + float: { type: "number", validate: validateNumber }, + // C-type double + double: { type: "number", validate: validateNumber }, + // hint to the UI to hide input strings + password: true, + // unchecked string payload + binary: true + }; + exports.fastFormats = { + ...exports.fullFormats, + date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate), + time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime), + "date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime), + "iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime), + "iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime), + // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js + uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i, + "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, + // email (sources from jsen validator): + // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363 + // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation') + 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 isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + 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 && isLeapYear(year) ? 29 : DAYS[month]); + } + function compareDate(d1, d2) { + if (!(d1 && d2)) + return void 0; + if (d1 > d2) + return 1; + if (d1 < d2) + return -1; + return 0; + } + var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i; + function getTime(strictTimeZone) { + return function time3(str) { + const matches = TIME.exec(str); + if (!matches) + return false; + const hr = +matches[1]; + const min = +matches[2]; + const sec = +matches[3]; + const tz = matches[4]; + const tzSign = matches[5] === "-" ? -1 : 1; + const tzH = +(matches[6] || 0); + const tzM = +(matches[7] || 0); + if (tzH > 23 || tzM > 59 || strictTimeZone && !tz) + return false; + if (hr <= 23 && min <= 59 && sec < 60) + return true; + const utcMin = min - tzM * tzSign; + const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0); + return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61; + }; + } + function compareTime(s1, s2) { + if (!(s1 && s2)) + return void 0; + const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf(); + const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf(); + if (!(t1 && t2)) + return void 0; + return t1 - t2; + } + function compareIsoTime(t1, t2) { + if (!(t1 && t2)) + return void 0; + const a1 = TIME.exec(t1); + const a2 = TIME.exec(t2); + if (!(a1 && a2)) + return void 0; + t1 = a1[1] + a1[2] + a1[3]; + t2 = a2[1] + a2[2] + a2[3]; + if (t1 > t2) + return 1; + if (t1 < t2) + return -1; + return 0; + } + var DATE_TIME_SEPARATOR = /t|\s/i; + function getDateTime(strictTimeZone) { + 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) { + if (!(dt1 && dt2)) + return void 0; + const d1 = new Date(dt1).valueOf(); + const d2 = new Date(dt2).valueOf(); + if (!(d1 && d2)) + return void 0; + return d1 - d2; + } + function compareIsoDateTime(dt1, dt2) { + if (!(dt1 && dt2)) + return void 0; + 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_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 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) { + BYTE.lastIndex = 0; + return BYTE.test(str); + } + var MIN_INT32 = -(2 ** 31); + var MAX_INT32 = 2 ** 31 - 1; + function validateInt32(value) { + return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32; + } + function validateInt64(value) { + return Number.isInteger(value); + } + function validateNumber() { + return true; + } + var Z_ANCHOR = /[^\\]\\Z/; + function regex(str) { + if (Z_ANCHOR.test(str)) + return false; + try { + new RegExp(str); + return true; + } catch (e) { + return false; + } + } + } +}); + +// node_modules/ajv-formats/dist/limit.js +var require_limit = __commonJS({ + "node_modules/ajv-formats/dist/limit.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.formatLimitDefinition = void 0; + var ajv_1 = require_ajv(); + var codegen_1 = require_codegen(); + var ops = codegen_1.operators; + var KWDs = { + formatMaximum: { okStr: "<=", ok: ops.LTE, fail: ops.GT }, + formatMinimum: { okStr: ">=", ok: ops.GTE, fail: ops.LT }, + formatExclusiveMaximum: { okStr: "<", ok: ops.LT, fail: ops.GTE }, + formatExclusiveMinimum: { okStr: ">", ok: ops.GT, fail: ops.LTE } + }; + var error2 = { + message: ({ keyword, schemaCode }) => (0, codegen_1.str)`should be ${KWDs[keyword].okStr} ${schemaCode}`, + params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}` + }; + exports.formatLimitDefinition = { + keyword: Object.keys(KWDs), + type: "string", + schemaType: "string", + $data: true, + error: error2, + code(cxt) { + const { gen, data, schemaCode, keyword, it } = cxt; + const { opts, self } = it; + if (!opts.validateFormats) + return; + const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format"); + if (fCxt.$data) + validate$DataFormat(); + else + validateFormat(); + function validate$DataFormat() { + const fmts = gen.scopeValue("formats", { + ref: self.formats, + code: opts.code.formats + }); + const fmt = gen.const("fmt", (0, codegen_1._)`${fmts}[${fCxt.schemaCode}]`); + 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 format = fCxt.schema; + const fmtDef = self.formats[format]; + if (!fmtDef || fmtDef === true) + return; + if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") { + throw new Error(`"${keyword}": format "${format}" does not define "compare" function`); + } + const fmt = gen.scopeValue("formats", { + key: format, + ref: fmtDef, + code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0 + }); + cxt.fail$data(compareCode(fmt)); + } + function compareCode(fmt) { + return (0, codegen_1._)`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword].fail} 0`; + } + }, + dependencies: ["format"] + }; + var formatLimitPlugin = (ajv) => { + ajv.addKeyword(exports.formatLimitDefinition); + return ajv; + }; + exports.default = formatLimitPlugin; + } +}); + +// node_modules/ajv-formats/dist/index.js +var require_dist = __commonJS({ + "node_modules/ajv-formats/dist/index.js"(exports, module) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + var formats_1 = require_formats(); + var limit_1 = require_limit(); + var codegen_1 = require_codegen(); + var fullName = new codegen_1.Name("fullFormats"); + var fastName = new codegen_1.Name("fastFormats"); + var formatsPlugin = (ajv, opts = { keywords: true }) => { + if (Array.isArray(opts)) { + addFormats(ajv, opts, formats_1.fullFormats, fullName); + return ajv; + } + const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName]; + const list = opts.formats || formats_1.formatNames; + addFormats(ajv, list, formats, exportName); + if (opts.keywords) + (0, limit_1.default)(ajv); + return ajv; + }; + formatsPlugin.get = (name, mode = "full") => { + const formats = mode === "fast" ? formats_1.fastFormats : formats_1.fullFormats; + const f = formats[name]; + if (!f) + throw new Error(`Unknown format "${name}"`); + return f; + }; + function addFormats(ajv, list, fs4, exportName) { + var _a2; + var _b; + (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`; + for (const f of list) + ajv.addFormat(f, fs4[f]); + } + module.exports = exports = formatsPlugin; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.default = formatsPlugin; + } +}); + +// node_modules/dotenv/package.json +var require_package = __commonJS({ + "node_modules/dotenv/package.json"(exports, module) { + module.exports = { + name: "dotenv", + version: "16.6.1", + description: "Loads environment variables from .env file", + main: "lib/main.js", + types: "lib/main.d.ts", + exports: { + ".": { + types: "./lib/main.d.ts", + require: "./lib/main.js", + default: "./lib/main.js" + }, + "./config": "./config.js", + "./config.js": "./config.js", + "./lib/env-options": "./lib/env-options.js", + "./lib/env-options.js": "./lib/env-options.js", + "./lib/cli-options": "./lib/cli-options.js", + "./lib/cli-options.js": "./lib/cli-options.js", + "./package.json": "./package.json" + }, + scripts: { + "dts-check": "tsc --project tests/types/tsconfig.json", + lint: "standard", + pretest: "npm run lint && npm run dts-check", + test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000", + "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov", + prerelease: "npm test", + release: "standard-version" + }, + repository: { + type: "git", + url: "git://github.com/motdotla/dotenv.git" + }, + homepage: "https://github.com/motdotla/dotenv#readme", + funding: "https://dotenvx.com", + keywords: [ + "dotenv", + "env", + ".env", + "environment", + "variables", + "config", + "settings" + ], + readmeFilename: "README.md", + license: "BSD-2-Clause", + devDependencies: { + "@types/node": "^18.11.3", + decache: "^4.6.2", + sinon: "^14.0.1", + standard: "^17.0.0", + "standard-version": "^9.5.0", + tap: "^19.2.0", + typescript: "^4.8.4" + }, + engines: { + node: ">=12" + }, + browser: { + fs: false + } + }; + } +}); + +// node_modules/dotenv/lib/main.js +var require_main = __commonJS({ + "node_modules/dotenv/lib/main.js"(exports, module) { + var fs4 = __require("fs"); + var path3 = __require("path"); + var os3 = __require("os"); + var crypto2 = __require("crypto"); + var packageJson = require_package(); + var version2 = packageJson.version; + var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg; + function parse4(src) { + const obj = {}; + let lines = src.toString(); + lines = lines.replace(/\r\n?/mg, "\n"); + let match; + while ((match = LINE.exec(lines)) != null) { + const key = match[1]; + let value = match[2] || ""; + value = value.trim(); + const maybeQuote = value[0]; + value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2"); + if (maybeQuote === '"') { + value = value.replace(/\\n/g, "\n"); + value = value.replace(/\\r/g, "\r"); + } + obj[key] = value; + } + return obj; + } + function _parseVault(options) { + options = options || {}; + const vaultPath = _vaultPath(options); + options.path = vaultPath; + const result = DotenvModule.configDotenv(options); + if (!result.parsed) { + const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`); + err.code = "MISSING_DATA"; + throw err; + } + const keys = _dotenvKey(options).split(","); + const length = keys.length; + let decrypted; + for (let i = 0; i < length; i++) { + try { + const key = keys[i].trim(); + const attrs = _instructions(result, key); + decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key); + break; + } catch (error2) { + if (i + 1 >= length) { + throw error2; + } + } + } + return DotenvModule.parse(decrypted); + } + function _warn(message) { + console.log(`[dotenv@${version2}][WARN] ${message}`); + } + function _debug(message) { + console.log(`[dotenv@${version2}][DEBUG] ${message}`); + } + function _log(message) { + console.log(`[dotenv@${version2}] ${message}`); + } + function _dotenvKey(options) { + if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) { + return options.DOTENV_KEY; + } + if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) { + return process.env.DOTENV_KEY; + } + return ""; + } + function _instructions(result, dotenvKey) { + let uri; + try { + uri = new URL(dotenvKey); + } catch (error2) { + if (error2.code === "ERR_INVALID_URL") { + const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } + throw error2; + } + const key = uri.password; + if (!key) { + const err = new Error("INVALID_DOTENV_KEY: Missing key part"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } + const environment = uri.searchParams.get("environment"); + if (!environment) { + const err = new Error("INVALID_DOTENV_KEY: Missing environment part"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } + const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`; + const ciphertext = result.parsed[environmentKey]; + if (!ciphertext) { + const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`); + err.code = "NOT_FOUND_DOTENV_ENVIRONMENT"; + throw err; + } + return { ciphertext, key }; + } + function _vaultPath(options) { + let possibleVaultPath = null; + if (options && options.path && options.path.length > 0) { + if (Array.isArray(options.path)) { + for (const filepath of options.path) { + if (fs4.existsSync(filepath)) { + possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`; + } + } + } else { + possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`; + } + } else { + possibleVaultPath = path3.resolve(process.cwd(), ".env.vault"); + } + if (fs4.existsSync(possibleVaultPath)) { + return possibleVaultPath; + } + return null; + } + function _resolveHome(envPath) { + return envPath[0] === "~" ? path3.join(os3.homedir(), envPath.slice(1)) : envPath; + } + function _configVault(options) { + const debug = Boolean(options && options.debug); + const quiet = options && "quiet" in options ? options.quiet : true; + if (debug || !quiet) { + _log("Loading env from encrypted .env.vault"); + } + const parsed = DotenvModule._parseVault(options); + let processEnv = process.env; + if (options && options.processEnv != null) { + processEnv = options.processEnv; + } + DotenvModule.populate(processEnv, parsed, options); + return { parsed }; + } + function configDotenv(options) { + const dotenvPath = path3.resolve(process.cwd(), ".env"); + let encoding = "utf8"; + const debug = Boolean(options && options.debug); + const quiet = options && "quiet" in options ? options.quiet : true; + if (options && options.encoding) { + encoding = options.encoding; + } else { + if (debug) { + _debug("No encoding is specified. UTF-8 is used by default"); + } + } + let optionPaths = [dotenvPath]; + if (options && options.path) { + if (!Array.isArray(options.path)) { + optionPaths = [_resolveHome(options.path)]; + } else { + optionPaths = []; + for (const filepath of options.path) { + optionPaths.push(_resolveHome(filepath)); + } + } + } + let lastError; + const parsedAll = {}; + for (const path4 of optionPaths) { + try { + const parsed = DotenvModule.parse(fs4.readFileSync(path4, { encoding })); + DotenvModule.populate(parsedAll, parsed, options); + } catch (e) { + if (debug) { + _debug(`Failed to load ${path4} ${e.message}`); + } + lastError = e; + } + } + let processEnv = process.env; + if (options && options.processEnv != null) { + processEnv = options.processEnv; + } + DotenvModule.populate(processEnv, parsedAll, options); + if (debug || !quiet) { + const keysCount = Object.keys(parsedAll).length; + const shortPaths = []; + for (const filePath of optionPaths) { + try { + const relative = path3.relative(process.cwd(), filePath); + shortPaths.push(relative); + } catch (e) { + if (debug) { + _debug(`Failed to load ${filePath} ${e.message}`); + } + lastError = e; + } + } + _log(`injecting env (${keysCount}) from ${shortPaths.join(",")}`); + } + if (lastError) { + return { parsed: parsedAll, error: lastError }; + } else { + return { parsed: parsedAll }; + } + } + function config3(options) { + if (_dotenvKey(options).length === 0) { + return DotenvModule.configDotenv(options); + } + const vaultPath = _vaultPath(options); + if (!vaultPath) { + _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`); + return DotenvModule.configDotenv(options); + } + return DotenvModule._configVault(options); + } + function decrypt(encrypted, keyStr) { + const key = Buffer.from(keyStr.slice(-64), "hex"); + let ciphertext = Buffer.from(encrypted, "base64"); + const nonce = ciphertext.subarray(0, 12); + const authTag = ciphertext.subarray(-16); + ciphertext = ciphertext.subarray(12, -16); + try { + const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce); + aesgcm.setAuthTag(authTag); + return `${aesgcm.update(ciphertext)}${aesgcm.final()}`; + } catch (error2) { + const isRange = error2 instanceof RangeError; + const invalidKeyLength = error2.message === "Invalid key length"; + const decryptionFailed = error2.message === "Unsupported state or unable to authenticate data"; + if (isRange || invalidKeyLength) { + const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)"); + err.code = "INVALID_DOTENV_KEY"; + throw err; + } else if (decryptionFailed) { + const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY"); + err.code = "DECRYPTION_FAILED"; + throw err; + } else { + throw error2; + } + } + } + function populate(processEnv, parsed, options = {}) { + const debug = Boolean(options && options.debug); + const override = Boolean(options && options.override); + if (typeof parsed !== "object") { + const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate"); + err.code = "OBJECT_REQUIRED"; + throw err; + } + for (const key of Object.keys(parsed)) { + if (Object.prototype.hasOwnProperty.call(processEnv, key)) { + if (override === true) { + processEnv[key] = parsed[key]; + } + if (debug) { + if (override === true) { + _debug(`"${key}" is already defined and WAS overwritten`); + } else { + _debug(`"${key}" is already defined and was NOT overwritten`); + } + } + } else { + processEnv[key] = parsed[key]; + } + } + } + var DotenvModule = { + configDotenv, + _configVault, + _parseVault, + config: config3, + decrypt, + parse: parse4, + populate + }; + module.exports.configDotenv = DotenvModule.configDotenv; + module.exports._configVault = DotenvModule._configVault; + module.exports._parseVault = DotenvModule._parseVault; + module.exports.config = DotenvModule.config; + module.exports.decrypt = DotenvModule.decrypt; + module.exports.parse = DotenvModule.parse; + module.exports.populate = DotenvModule.populate; + module.exports = DotenvModule; + } +}); + +// src/websocket-server.js +import * as fs3 from "fs/promises"; + +// node_modules/ws/wrapper.mjs +var import_stream = __toESM(require_stream(), 1); +var import_receiver = __toESM(require_receiver(), 1); +var import_sender = __toESM(require_sender(), 1); +var import_websocket = __toESM(require_websocket(), 1); +var import_websocket_server = __toESM(require_websocket_server(), 1); +var wrapper_default = import_websocket.default; + +// src/websocket-server.js +import { createServer } from "http"; +import { parse as parse3 } from "url"; +import { fork, execSync as execSync2 } from "child_process"; + +// node_modules/zod/v3/helpers/util.js +var util; +(function(util2) { + util2.assertEqual = (_) => { + }; + function assertIs2(_arg) { + } + util2.assertIs = assertIs2; + function assertNever2(_x) { + throw new Error(); + } + util2.assertNever = assertNever2; + util2.arrayToEnum = (items) => { + const obj = {}; + for (const item of items) { + obj[item] = item; + } + return obj; + }; + util2.getValidEnumValues = (obj) => { + const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number"); + const filtered = {}; + for (const k of validKeys) { + filtered[k] = obj[k]; + } + return util2.objectValues(filtered); + }; + util2.objectValues = (obj) => { + return util2.objectKeys(obj).map(function(e) { + return obj[e]; + }); + }; + util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object3) => { + const keys = []; + for (const key in object3) { + if (Object.prototype.hasOwnProperty.call(object3, key)) { + keys.push(key); + } + } + return keys; + }; + util2.find = (arr, checker) => { + for (const item of arr) { + if (checker(item)) + return item; + } + return void 0; + }; + util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val; + function joinValues2(array2, separator = " | ") { + return array2.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator); + } + util2.joinValues = joinValues2; + util2.jsonStringifyReplacer = (_, value) => { + if (typeof value === "bigint") { + return value.toString(); + } + return value; + }; +})(util || (util = {})); +var objectUtil; +(function(objectUtil2) { + objectUtil2.mergeShapes = (first, second) => { + return { + ...first, + ...second + // second overwrites first + }; + }; +})(objectUtil || (objectUtil = {})); +var ZodParsedType = util.arrayToEnum([ + "string", + "nan", + "number", + "integer", + "float", + "boolean", + "date", + "bigint", + "symbol", + "function", + "undefined", + "null", + "array", + "object", + "unknown", + "promise", + "void", + "never", + "map", + "set" +]); +var getParsedType = (data) => { + const t = typeof data; + switch (t) { + case "undefined": + return ZodParsedType.undefined; + case "string": + return ZodParsedType.string; + case "number": + return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number; + case "boolean": + return ZodParsedType.boolean; + case "function": + return ZodParsedType.function; + case "bigint": + return ZodParsedType.bigint; + case "symbol": + return ZodParsedType.symbol; + case "object": + if (Array.isArray(data)) { + return ZodParsedType.array; + } + if (data === null) { + return ZodParsedType.null; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return ZodParsedType.promise; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return ZodParsedType.map; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return ZodParsedType.set; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return ZodParsedType.date; + } + return ZodParsedType.object; + default: + return ZodParsedType.unknown; + } +}; + +// node_modules/zod/v3/ZodError.js +var ZodIssueCode = util.arrayToEnum([ + "invalid_type", + "invalid_literal", + "custom", + "invalid_union", + "invalid_union_discriminator", + "invalid_enum_value", + "unrecognized_keys", + "invalid_arguments", + "invalid_return_type", + "invalid_date", + "invalid_string", + "too_small", + "too_big", + "invalid_intersection_types", + "not_multiple_of", + "not_finite" +]); +var ZodError = class _ZodError extends Error { + get errors() { + return this.issues; + } + constructor(issues) { + super(); + this.issues = []; + this.addIssue = (sub) => { + this.issues = [...this.issues, sub]; + }; + this.addIssues = (subs = []) => { + this.issues = [...this.issues, ...subs]; + }; + const actualProto = new.target.prototype; + if (Object.setPrototypeOf) { + Object.setPrototypeOf(this, actualProto); + } else { + this.__proto__ = actualProto; + } + this.name = "ZodError"; + this.issues = issues; + } + format(_mapper) { + const mapper = _mapper || function(issue2) { + return issue2.message; + }; + const fieldErrors = { _errors: [] }; + const processError = (error2) => { + for (const issue2 of error2.issues) { + if (issue2.code === "invalid_union") { + issue2.unionErrors.map(processError); + } else if (issue2.code === "invalid_return_type") { + processError(issue2.returnTypeError); + } else if (issue2.code === "invalid_arguments") { + processError(issue2.argumentsError); + } else if (issue2.path.length === 0) { + fieldErrors._errors.push(mapper(issue2)); + } else { + let curr = fieldErrors; + let i = 0; + while (i < issue2.path.length) { + const el = issue2.path[i]; + const terminal = i === issue2.path.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue2)); + } + curr = curr[el]; + i++; + } + } + } + }; + processError(this); + return fieldErrors; + } + static assert(value) { + if (!(value instanceof _ZodError)) { + throw new Error(`Not a ZodError: ${value}`); + } + } + toString() { + return this.message; + } + get message() { + return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2); + } + get isEmpty() { + return this.issues.length === 0; + } + flatten(mapper = (issue2) => issue2.message) { + const fieldErrors = /* @__PURE__ */ Object.create(null); + const formErrors = []; + for (const sub of this.issues) { + if (sub.path.length > 0) { + const firstEl = sub.path[0]; + fieldErrors[firstEl] = fieldErrors[firstEl] || []; + fieldErrors[firstEl].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; + } + get formErrors() { + return this.flatten(); + } +}; +ZodError.create = (issues) => { + const error2 = new ZodError(issues); + return error2; +}; + +// node_modules/zod/v3/locales/en.js +var errorMap = (issue2, _ctx) => { + let message; + switch (issue2.code) { + case ZodIssueCode.invalid_type: + if (issue2.received === ZodParsedType.undefined) { + message = "Required"; + } else { + message = `Expected ${issue2.expected}, received ${issue2.received}`; + } + break; + case ZodIssueCode.invalid_literal: + message = `Invalid literal value, expected ${JSON.stringify(issue2.expected, util.jsonStringifyReplacer)}`; + break; + case ZodIssueCode.unrecognized_keys: + message = `Unrecognized key(s) in object: ${util.joinValues(issue2.keys, ", ")}`; + break; + case ZodIssueCode.invalid_union: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_union_discriminator: + message = `Invalid discriminator value. Expected ${util.joinValues(issue2.options)}`; + break; + case ZodIssueCode.invalid_enum_value: + message = `Invalid enum value. Expected ${util.joinValues(issue2.options)}, received '${issue2.received}'`; + break; + case ZodIssueCode.invalid_arguments: + message = `Invalid function arguments`; + break; + case ZodIssueCode.invalid_return_type: + message = `Invalid function return type`; + break; + case ZodIssueCode.invalid_date: + message = `Invalid date`; + break; + case ZodIssueCode.invalid_string: + if (typeof issue2.validation === "object") { + if ("includes" in issue2.validation) { + message = `Invalid input: must include "${issue2.validation.includes}"`; + if (typeof issue2.validation.position === "number") { + message = `${message} at one or more positions greater than or equal to ${issue2.validation.position}`; + } + } else if ("startsWith" in issue2.validation) { + message = `Invalid input: must start with "${issue2.validation.startsWith}"`; + } else if ("endsWith" in issue2.validation) { + message = `Invalid input: must end with "${issue2.validation.endsWith}"`; + } else { + util.assertNever(issue2.validation); + } + } else if (issue2.validation !== "regex") { + message = `Invalid ${issue2.validation}`; + } else { + message = "Invalid"; + } + break; + case ZodIssueCode.too_small: + if (issue2.type === "array") + message = `Array must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `more than`} ${issue2.minimum} element(s)`; + else if (issue2.type === "string") + message = `String must contain ${issue2.exact ? "exactly" : issue2.inclusive ? `at least` : `over`} ${issue2.minimum} character(s)`; + else if (issue2.type === "number") + message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`; + else if (issue2.type === "bigint") + message = `Number must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${issue2.minimum}`; + else if (issue2.type === "date") + message = `Date must be ${issue2.exact ? `exactly equal to ` : issue2.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue2.minimum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.too_big: + if (issue2.type === "array") + message = `Array must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `less than`} ${issue2.maximum} element(s)`; + else if (issue2.type === "string") + message = `String must contain ${issue2.exact ? `exactly` : issue2.inclusive ? `at most` : `under`} ${issue2.maximum} character(s)`; + else if (issue2.type === "number") + message = `Number must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`; + else if (issue2.type === "bigint") + message = `BigInt must be ${issue2.exact ? `exactly` : issue2.inclusive ? `less than or equal to` : `less than`} ${issue2.maximum}`; + else if (issue2.type === "date") + message = `Date must be ${issue2.exact ? `exactly` : issue2.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue2.maximum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.custom: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_intersection_types: + message = `Intersection results could not be merged`; + break; + case ZodIssueCode.not_multiple_of: + message = `Number must be a multiple of ${issue2.multipleOf}`; + break; + case ZodIssueCode.not_finite: + message = "Number must be finite"; + break; + default: + message = _ctx.defaultError; + util.assertNever(issue2); + } + return { message }; +}; +var en_default = errorMap; + +// node_modules/zod/v3/errors.js +var overrideErrorMap = en_default; +function getErrorMap() { + return overrideErrorMap; +} + +// node_modules/zod/v3/helpers/parseUtil.js +var makeIssue = (params) => { + const { data, path: path3, errorMaps, issueData } = params; + const fullPath = [...path3, ...issueData.path || []]; + const fullIssue = { + ...issueData, + path: fullPath + }; + if (issueData.message !== void 0) { + return { + ...issueData, + path: fullPath, + message: issueData.message + }; + } + let errorMessage = ""; + const maps = errorMaps.filter((m) => !!m).slice().reverse(); + for (const map2 of maps) { + errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message; + } + return { + ...issueData, + path: fullPath, + message: errorMessage + }; +}; +function addIssueToContext(ctx, issueData) { + const overrideMap = getErrorMap(); + const issue2 = makeIssue({ + issueData, + data: ctx.data, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + // contextual error map is first priority + ctx.schemaErrorMap, + // then schema-bound map if available + overrideMap, + // then global override map + overrideMap === en_default ? void 0 : en_default + // then global default map + ].filter((x) => !!x) + }); + ctx.common.issues.push(issue2); +} +var ParseStatus = class _ParseStatus { + constructor() { + this.value = "valid"; + } + dirty() { + if (this.value === "valid") + this.value = "dirty"; + } + abort() { + if (this.value !== "aborted") + this.value = "aborted"; + } + static mergeArray(status, results) { + const arrayValue = []; + for (const s of results) { + if (s.status === "aborted") + return INVALID; + if (s.status === "dirty") + status.dirty(); + arrayValue.push(s.value); + } + return { status: status.value, value: arrayValue }; + } + static async mergeObjectAsync(status, pairs) { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value + }); + } + return _ParseStatus.mergeObjectSync(status, syncPairs); + } + static mergeObjectSync(status, pairs) { + const finalObject = {}; + for (const pair of pairs) { + const { key, value } = pair; + if (key.status === "aborted") + return INVALID; + if (value.status === "aborted") + return INVALID; + if (key.status === "dirty") + status.dirty(); + if (value.status === "dirty") + status.dirty(); + if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) { + finalObject[key.value] = value.value; + } + } + return { status: status.value, value: finalObject }; + } +}; +var INVALID = Object.freeze({ + status: "aborted" +}); +var DIRTY = (value) => ({ status: "dirty", value }); +var OK = (value) => ({ status: "valid", value }); +var isAborted = (x) => x.status === "aborted"; +var isDirty = (x) => x.status === "dirty"; +var isValid = (x) => x.status === "valid"; +var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise; + +// node_modules/zod/v3/helpers/errorUtil.js +var errorUtil; +(function(errorUtil2) { + errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {}; + errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message; +})(errorUtil || (errorUtil = {})); + +// node_modules/zod/v3/types.js +var ParseInputLazyPath = class { + constructor(parent, value, path3, key) { + this._cachedPath = []; + this.parent = parent; + this.data = value; + this._path = path3; + this._key = key; + } + get path() { + if (!this._cachedPath.length) { + if (Array.isArray(this._key)) { + this._cachedPath.push(...this._path, ...this._key); + } else { + this._cachedPath.push(...this._path, this._key); + } + } + return this._cachedPath; + } +}; +var handleResult = (ctx, result) => { + if (isValid(result)) { + return { success: true, data: result.value }; + } else { + if (!ctx.common.issues.length) { + throw new Error("Validation failed but no issues detected."); + } + return { + success: false, + get error() { + if (this._error) + return this._error; + const error2 = new ZodError(ctx.common.issues); + this._error = error2; + return this._error; + } + }; + } +}; +function processCreateParams(params) { + if (!params) + return {}; + const { errorMap: errorMap2, invalid_type_error, required_error, description } = params; + if (errorMap2 && (invalid_type_error || required_error)) { + throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + } + if (errorMap2) + return { errorMap: errorMap2, description }; + const customMap = (iss, ctx) => { + const { message } = params; + if (iss.code === "invalid_enum_value") { + return { message: message ?? ctx.defaultError }; + } + if (typeof ctx.data === "undefined") { + return { message: message ?? required_error ?? ctx.defaultError }; + } + if (iss.code !== "invalid_type") + return { message: ctx.defaultError }; + return { message: message ?? invalid_type_error ?? ctx.defaultError }; + }; + return { errorMap: customMap, description }; +} +var ZodType = class { + get description() { + return this._def.description; + } + _getType(input) { + return getParsedType(input.data); + } + _getOrReturnCtx(input, ctx) { + return ctx || { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent + }; + } + _processInputParams(input) { + return { + status: new ParseStatus(), + ctx: { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent + } + }; + } + _parseSync(input) { + const result = this._parse(input); + if (isAsync(result)) { + throw new Error("Synchronous parse encountered promise."); + } + return result; + } + _parseAsync(input) { + const result = this._parse(input); + return Promise.resolve(result); + } + parse(data, params) { + const result = this.safeParse(data, params); + if (result.success) + return result.data; + throw result.error; + } + safeParse(data, params) { + const ctx = { + common: { + issues: [], + async: params?.async ?? false, + contextualErrorMap: params?.errorMap + }, + path: params?.path || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + const result = this._parseSync({ data, path: ctx.path, parent: ctx }); + return handleResult(ctx, result); + } + "~validate"(data) { + const ctx = { + common: { + issues: [], + async: !!this["~standard"].async + }, + path: [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + if (!this["~standard"].async) { + try { + const result = this._parseSync({ data, path: [], parent: ctx }); + return isValid(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }; + } catch (err) { + if (err?.message?.toLowerCase()?.includes("encountered")) { + this["~standard"].async = true; + } + ctx.common = { + issues: [], + async: true + }; + } + } + return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }); + } + async parseAsync(data, params) { + const result = await this.safeParseAsync(data, params); + if (result.success) + return result.data; + throw result.error; + } + async safeParseAsync(data, params) { + const ctx = { + common: { + issues: [], + contextualErrorMap: params?.errorMap, + async: true + }, + path: params?.path || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx }); + const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult)); + return handleResult(ctx, result); + } + refine(check2, message) { + const getIssueProperties = (val) => { + if (typeof message === "string" || typeof message === "undefined") { + return { message }; + } else if (typeof message === "function") { + return message(val); + } else { + return message; + } + }; + return this._refinement((val, ctx) => { + const result = check2(val); + const setError = () => ctx.addIssue({ + code: ZodIssueCode.custom, + ...getIssueProperties(val) + }); + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then((data) => { + if (!data) { + setError(); + return false; + } else { + return true; + } + }); + } + if (!result) { + setError(); + return false; + } else { + return true; + } + }); + } + refinement(check2, refinementData) { + return this._refinement((val, ctx) => { + if (!check2(val)) { + ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData); + return false; + } else { + return true; + } + }); + } + _refinement(refinement) { + return new ZodEffects({ + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "refinement", refinement } + }); + } + superRefine(refinement) { + return this._refinement(refinement); + } + constructor(def) { + this.spa = this.safeParseAsync; + this._def = def; + this.parse = this.parse.bind(this); + this.safeParse = this.safeParse.bind(this); + this.parseAsync = this.parseAsync.bind(this); + this.safeParseAsync = this.safeParseAsync.bind(this); + this.spa = this.spa.bind(this); + this.refine = this.refine.bind(this); + this.refinement = this.refinement.bind(this); + this.superRefine = this.superRefine.bind(this); + this.optional = this.optional.bind(this); + this.nullable = this.nullable.bind(this); + this.nullish = this.nullish.bind(this); + this.array = this.array.bind(this); + this.promise = this.promise.bind(this); + this.or = this.or.bind(this); + this.and = this.and.bind(this); + this.transform = this.transform.bind(this); + this.brand = this.brand.bind(this); + this.default = this.default.bind(this); + this.catch = this.catch.bind(this); + this.describe = this.describe.bind(this); + this.pipe = this.pipe.bind(this); + this.readonly = this.readonly.bind(this); + this.isNullable = this.isNullable.bind(this); + this.isOptional = this.isOptional.bind(this); + this["~standard"] = { + version: 1, + vendor: "zod", + validate: (data) => this["~validate"](data) + }; + } + optional() { + return ZodOptional.create(this, this._def); + } + nullable() { + return ZodNullable.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return ZodArray.create(this); + } + promise() { + return ZodPromise.create(this, this._def); + } + or(option) { + return ZodUnion.create([this, option], this._def); + } + and(incoming) { + return ZodIntersection.create(this, incoming, this._def); + } + transform(transform2) { + return new ZodEffects({ + ...processCreateParams(this._def), + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "transform", transform: transform2 } + }); + } + default(def) { + const defaultValueFunc = typeof def === "function" ? def : () => def; + return new ZodDefault({ + ...processCreateParams(this._def), + innerType: this, + defaultValue: defaultValueFunc, + typeName: ZodFirstPartyTypeKind.ZodDefault + }); + } + brand() { + return new ZodBranded({ + typeName: ZodFirstPartyTypeKind.ZodBranded, + type: this, + ...processCreateParams(this._def) + }); + } + catch(def) { + const catchValueFunc = typeof def === "function" ? def : () => def; + return new ZodCatch({ + ...processCreateParams(this._def), + innerType: this, + catchValue: catchValueFunc, + typeName: ZodFirstPartyTypeKind.ZodCatch + }); + } + describe(description) { + const This = this.constructor; + return new This({ + ...this._def, + description + }); + } + pipe(target) { + return ZodPipeline.create(this, target); + } + readonly() { + return ZodReadonly.create(this); + } + isOptional() { + return this.safeParse(void 0).success; + } + isNullable() { + return this.safeParse(null).success; + } +}; +var cuidRegex = /^c[^\s-]{8,}$/i; +var cuid2Regex = /^[0-9a-z]+$/; +var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i; +var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i; +var nanoidRegex = /^[a-z0-9_-]{21}$/i; +var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/; +var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/; +var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i; +var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +var emojiRegex; +var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; +var ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/; +var ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/; +var ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/; +var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/; +var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`; +var dateRegex = new RegExp(`^${dateRegexSource}$`); +function timeRegexSource(args) { + let secondsRegexSource = `[0-5]\\d`; + if (args.precision) { + secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`; + } else if (args.precision == null) { + secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`; + } + const secondsQuantifier = args.precision ? "+" : "?"; + return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`; +} +function timeRegex(args) { + return new RegExp(`^${timeRegexSource(args)}$`); +} +function datetimeRegex(args) { + let regex = `${dateRegexSource}T${timeRegexSource(args)}`; + const opts = []; + opts.push(args.local ? `Z?` : `Z`); + if (args.offset) + opts.push(`([+-]\\d{2}:?\\d{2})`); + regex = `${regex}(${opts.join("|")})`; + return new RegExp(`^${regex}$`); +} +function isValidIP(ip, version2) { + if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) { + return true; + } + if ((version2 === "v6" || !version2) && ipv6Regex.test(ip)) { + return true; + } + return false; +} +function isValidJWT(jwt2, alg) { + if (!jwtRegex.test(jwt2)) + return false; + try { + const [header] = jwt2.split("."); + if (!header) + return false; + const base643 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "="); + const decoded = JSON.parse(atob(base643)); + if (typeof decoded !== "object" || decoded === null) + return false; + if ("typ" in decoded && decoded?.typ !== "JWT") + return false; + if (!decoded.alg) + return false; + if (alg && decoded.alg !== alg) + return false; + return true; + } catch { + return false; + } +} +function isValidCidr(ip, version2) { + if ((version2 === "v4" || !version2) && ipv4CidrRegex.test(ip)) { + return true; + } + if ((version2 === "v6" || !version2) && ipv6CidrRegex.test(ip)) { + return true; + } + return false; +} +var ZodString = class _ZodString2 extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = String(input.data); + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.string) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.string, + received: ctx2.parsedType + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check2 of this._def.checks) { + if (check2.kind === "min") { + if (input.data.length < check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check2.value, + type: "string", + inclusive: true, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "max") { + if (input.data.length > check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check2.value, + type: "string", + inclusive: true, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "length") { + const tooBig = input.data.length > check2.value; + const tooSmall = input.data.length < check2.value; + if (tooBig || tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + if (tooBig) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check2.value, + type: "string", + inclusive: true, + exact: true, + message: check2.message + }); + } else if (tooSmall) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check2.value, + type: "string", + inclusive: true, + exact: true, + message: check2.message + }); + } + status.dirty(); + } + } else if (check2.kind === "email") { + if (!emailRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "email", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "emoji") { + if (!emojiRegex) { + emojiRegex = new RegExp(_emojiRegex, "u"); + } + if (!emojiRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "emoji", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "uuid") { + if (!uuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "uuid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "nanoid") { + if (!nanoidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "nanoid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "cuid") { + if (!cuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "cuid2") { + if (!cuid2Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid2", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "ulid") { + if (!ulidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ulid", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "url") { + try { + new URL(input.data); + } catch { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "url", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "regex") { + check2.regex.lastIndex = 0; + const testResult = check2.regex.test(input.data); + if (!testResult) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "regex", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "trim") { + input.data = input.data.trim(); + } else if (check2.kind === "includes") { + if (!input.data.includes(check2.value, check2.position)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { includes: check2.value, position: check2.position }, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "toLowerCase") { + input.data = input.data.toLowerCase(); + } else if (check2.kind === "toUpperCase") { + input.data = input.data.toUpperCase(); + } else if (check2.kind === "startsWith") { + if (!input.data.startsWith(check2.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { startsWith: check2.value }, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "endsWith") { + if (!input.data.endsWith(check2.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { endsWith: check2.value }, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "datetime") { + const regex = datetimeRegex(check2); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "datetime", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "date") { + const regex = dateRegex; + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "date", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "time") { + const regex = timeRegex(check2); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "time", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "duration") { + if (!durationRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "duration", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "ip") { + if (!isValidIP(input.data, check2.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ip", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "jwt") { + if (!isValidJWT(input.data, check2.alg)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "jwt", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "cidr") { + if (!isValidCidr(input.data, check2.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cidr", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "base64") { + if (!base64Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "base64", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "base64url") { + if (!base64urlRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "base64url", + code: ZodIssueCode.invalid_string, + message: check2.message + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + return { status: status.value, value: input.data }; + } + _regex(regex, validation, message) { + return this.refinement((data) => regex.test(data), { + validation, + code: ZodIssueCode.invalid_string, + ...errorUtil.errToObj(message) + }); + } + _addCheck(check2) { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + email(message) { + return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) }); + } + url(message) { + return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) }); + } + emoji(message) { + return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) }); + } + uuid(message) { + return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) }); + } + nanoid(message) { + return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) }); + } + cuid(message) { + return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) }); + } + cuid2(message) { + return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) }); + } + ulid(message) { + return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) }); + } + base64(message) { + return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) }); + } + base64url(message) { + return this._addCheck({ + kind: "base64url", + ...errorUtil.errToObj(message) + }); + } + jwt(options) { + return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) }); + } + ip(options) { + return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) }); + } + cidr(options) { + return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) }); + } + datetime(options) { + if (typeof options === "string") { + return this._addCheck({ + kind: "datetime", + precision: null, + offset: false, + local: false, + message: options + }); + } + return this._addCheck({ + kind: "datetime", + precision: typeof options?.precision === "undefined" ? null : options?.precision, + offset: options?.offset ?? false, + local: options?.local ?? false, + ...errorUtil.errToObj(options?.message) + }); + } + date(message) { + return this._addCheck({ kind: "date", message }); + } + time(options) { + if (typeof options === "string") { + return this._addCheck({ + kind: "time", + precision: null, + message: options + }); + } + return this._addCheck({ + kind: "time", + precision: typeof options?.precision === "undefined" ? null : options?.precision, + ...errorUtil.errToObj(options?.message) + }); + } + duration(message) { + return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) }); + } + regex(regex, message) { + return this._addCheck({ + kind: "regex", + regex, + ...errorUtil.errToObj(message) + }); + } + includes(value, options) { + return this._addCheck({ + kind: "includes", + value, + position: options?.position, + ...errorUtil.errToObj(options?.message) + }); + } + startsWith(value, message) { + return this._addCheck({ + kind: "startsWith", + value, + ...errorUtil.errToObj(message) + }); + } + endsWith(value, message) { + return this._addCheck({ + kind: "endsWith", + value, + ...errorUtil.errToObj(message) + }); + } + min(minLength, message) { + return this._addCheck({ + kind: "min", + value: minLength, + ...errorUtil.errToObj(message) + }); + } + max(maxLength, message) { + return this._addCheck({ + kind: "max", + value: maxLength, + ...errorUtil.errToObj(message) + }); + } + length(len, message) { + return this._addCheck({ + kind: "length", + value: len, + ...errorUtil.errToObj(message) + }); + } + /** + * Equivalent to `.min(1)` + */ + nonempty(message) { + return this.min(1, errorUtil.errToObj(message)); + } + trim() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "trim" }] + }); + } + toLowerCase() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "toLowerCase" }] + }); + } + toUpperCase() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "toUpperCase" }] + }); + } + get isDatetime() { + return !!this._def.checks.find((ch) => ch.kind === "datetime"); + } + get isDate() { + return !!this._def.checks.find((ch) => ch.kind === "date"); + } + get isTime() { + return !!this._def.checks.find((ch) => ch.kind === "time"); + } + get isDuration() { + return !!this._def.checks.find((ch) => ch.kind === "duration"); + } + get isEmail() { + return !!this._def.checks.find((ch) => ch.kind === "email"); + } + get isURL() { + return !!this._def.checks.find((ch) => ch.kind === "url"); + } + get isEmoji() { + return !!this._def.checks.find((ch) => ch.kind === "emoji"); + } + get isUUID() { + return !!this._def.checks.find((ch) => ch.kind === "uuid"); + } + get isNANOID() { + return !!this._def.checks.find((ch) => ch.kind === "nanoid"); + } + get isCUID() { + return !!this._def.checks.find((ch) => ch.kind === "cuid"); + } + get isCUID2() { + return !!this._def.checks.find((ch) => ch.kind === "cuid2"); + } + get isULID() { + return !!this._def.checks.find((ch) => ch.kind === "ulid"); + } + get isIP() { + return !!this._def.checks.find((ch) => ch.kind === "ip"); + } + get isCIDR() { + return !!this._def.checks.find((ch) => ch.kind === "cidr"); + } + get isBase64() { + return !!this._def.checks.find((ch) => ch.kind === "base64"); + } + get isBase64url() { + return !!this._def.checks.find((ch) => ch.kind === "base64url"); + } + get minLength() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxLength() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } +}; +ZodString.create = (params) => { + return new ZodString({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodString, + coerce: params?.coerce ?? false, + ...processCreateParams(params) + }); +}; +function floatSafeRemainder(val, step) { + const valDecCount = (val.toString().split(".")[1] || "").length; + const stepDecCount = (step.toString().split(".")[1] || "").length; + const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; + const valInt = Number.parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", "")); + return valInt % stepInt / 10 ** decCount; +} +var ZodNumber = class _ZodNumber extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + this.step = this.multipleOf; + } + _parse(input) { + if (this._def.coerce) { + input.data = Number(input.data); + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.number) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.number, + received: ctx2.parsedType + }); + return INVALID; + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check2 of this._def.checks) { + if (check2.kind === "int") { + if (!util.isInteger(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: "integer", + received: "float", + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "min") { + const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check2.value, + type: "number", + inclusive: check2.inclusive, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "max") { + const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check2.value, + type: "number", + inclusive: check2.inclusive, + exact: false, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "multipleOf") { + if (floatSafeRemainder(input.data, check2.value) !== 0) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check2.value, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "finite") { + if (!Number.isFinite(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_finite, + message: check2.message + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + return { status: status.value, value: input.data }; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodNumber({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message) + } + ] + }); + } + _addCheck(check2) { + return new _ZodNumber({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + int(message) { + return this._addCheck({ + kind: "int", + message: errorUtil.toString(message) + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: false, + message: errorUtil.toString(message) + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: false, + message: errorUtil.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: true, + message: errorUtil.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: true, + message: errorUtil.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil.toString(message) + }); + } + finite(message) { + return this._addCheck({ + kind: "finite", + message: errorUtil.toString(message) + }); + } + safe(message) { + return this._addCheck({ + kind: "min", + inclusive: true, + value: Number.MIN_SAFE_INTEGER, + message: errorUtil.toString(message) + })._addCheck({ + kind: "max", + inclusive: true, + value: Number.MAX_SAFE_INTEGER, + message: errorUtil.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } + get isInt() { + return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value)); + } + get isFinite() { + let max = null; + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") { + return true; + } else if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } else if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return Number.isFinite(min) && Number.isFinite(max); + } +}; +ZodNumber.create = (params) => { + return new ZodNumber({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodNumber, + coerce: params?.coerce || false, + ...processCreateParams(params) + }); +}; +var ZodBigInt = class _ZodBigInt extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + } + _parse(input) { + if (this._def.coerce) { + try { + input.data = BigInt(input.data); + } catch { + return this._getInvalidInput(input); + } + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.bigint) { + return this._getInvalidInput(input); + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check2 of this._def.checks) { + if (check2.kind === "min") { + const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + type: "bigint", + minimum: check2.value, + inclusive: check2.inclusive, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "max") { + const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + type: "bigint", + maximum: check2.value, + inclusive: check2.inclusive, + message: check2.message + }); + status.dirty(); + } + } else if (check2.kind === "multipleOf") { + if (input.data % check2.value !== BigInt(0)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check2.value, + message: check2.message + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + return { status: status.value, value: input.data }; + } + _getInvalidInput(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.bigint, + received: ctx.parsedType + }); + return INVALID; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodBigInt({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message) + } + ] + }); + } + _addCheck(check2) { + return new _ZodBigInt({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message) + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } +}; +ZodBigInt.create = (params) => { + return new ZodBigInt({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodBigInt, + coerce: params?.coerce ?? false, + ...processCreateParams(params) + }); +}; +var ZodBoolean = class extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = Boolean(input.data); + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.boolean) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.boolean, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } +}; +ZodBoolean.create = (params) => { + return new ZodBoolean({ + typeName: ZodFirstPartyTypeKind.ZodBoolean, + coerce: params?.coerce || false, + ...processCreateParams(params) + }); +}; +var ZodDate = class _ZodDate extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = new Date(input.data); + } + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.date) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.date, + received: ctx2.parsedType + }); + return INVALID; + } + if (Number.isNaN(input.data.getTime())) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_date + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check2 of this._def.checks) { + if (check2.kind === "min") { + if (input.data.getTime() < check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + message: check2.message, + inclusive: true, + exact: false, + minimum: check2.value, + type: "date" + }); + status.dirty(); + } + } else if (check2.kind === "max") { + if (input.data.getTime() > check2.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + message: check2.message, + inclusive: true, + exact: false, + maximum: check2.value, + type: "date" + }); + status.dirty(); + } + } else { + util.assertNever(check2); + } + } + return { + status: status.value, + value: new Date(input.data.getTime()) + }; + } + _addCheck(check2) { + return new _ZodDate({ + ...this._def, + checks: [...this._def.checks, check2] + }); + } + min(minDate, message) { + return this._addCheck({ + kind: "min", + value: minDate.getTime(), + message: errorUtil.toString(message) + }); + } + max(maxDate, message) { + return this._addCheck({ + kind: "max", + value: maxDate.getTime(), + message: errorUtil.toString(message) + }); + } + get minDate() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min != null ? new Date(min) : null; + } + get maxDate() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max != null ? new Date(max) : null; + } +}; +ZodDate.create = (params) => { + return new ZodDate({ + checks: [], + coerce: params?.coerce || false, + typeName: ZodFirstPartyTypeKind.ZodDate, + ...processCreateParams(params) + }); +}; +var ZodSymbol = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.symbol) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.symbol, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } +}; +ZodSymbol.create = (params) => { + return new ZodSymbol({ + typeName: ZodFirstPartyTypeKind.ZodSymbol, + ...processCreateParams(params) + }); +}; +var ZodUndefined = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.undefined, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } +}; +ZodUndefined.create = (params) => { + return new ZodUndefined({ + typeName: ZodFirstPartyTypeKind.ZodUndefined, + ...processCreateParams(params) + }); +}; +var ZodNull = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.null) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.null, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } +}; +ZodNull.create = (params) => { + return new ZodNull({ + typeName: ZodFirstPartyTypeKind.ZodNull, + ...processCreateParams(params) + }); +}; +var ZodAny = class extends ZodType { + constructor() { + super(...arguments); + this._any = true; + } + _parse(input) { + return OK(input.data); + } +}; +ZodAny.create = (params) => { + return new ZodAny({ + typeName: ZodFirstPartyTypeKind.ZodAny, + ...processCreateParams(params) + }); +}; +var ZodUnknown = class extends ZodType { + constructor() { + super(...arguments); + this._unknown = true; + } + _parse(input) { + return OK(input.data); + } +}; +ZodUnknown.create = (params) => { + return new ZodUnknown({ + typeName: ZodFirstPartyTypeKind.ZodUnknown, + ...processCreateParams(params) + }); +}; +var ZodNever = class extends ZodType { + _parse(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.never, + received: ctx.parsedType + }); + return INVALID; + } +}; +ZodNever.create = (params) => { + return new ZodNever({ + typeName: ZodFirstPartyTypeKind.ZodNever, + ...processCreateParams(params) + }); +}; +var ZodVoid = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.void, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } +}; +ZodVoid.create = (params) => { + return new ZodVoid({ + typeName: ZodFirstPartyTypeKind.ZodVoid, + ...processCreateParams(params) + }); +}; +var ZodArray = class _ZodArray extends ZodType { + _parse(input) { + const { ctx, status } = this._processInputParams(input); + const def = this._def; + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType + }); + return INVALID; + } + if (def.exactLength !== null) { + const tooBig = ctx.data.length > def.exactLength.value; + const tooSmall = ctx.data.length < def.exactLength.value; + if (tooBig || tooSmall) { + addIssueToContext(ctx, { + code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small, + minimum: tooSmall ? def.exactLength.value : void 0, + maximum: tooBig ? def.exactLength.value : void 0, + type: "array", + inclusive: true, + exact: true, + message: def.exactLength.message + }); + status.dirty(); + } + } + if (def.minLength !== null) { + if (ctx.data.length < def.minLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.minLength.message + }); + status.dirty(); + } + } + if (def.maxLength !== null) { + if (ctx.data.length > def.maxLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.maxLength.message + }); + status.dirty(); + } + } + if (ctx.common.async) { + return Promise.all([...ctx.data].map((item, i) => { + return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i)); + })).then((result2) => { + return ParseStatus.mergeArray(status, result2); + }); + } + const result = [...ctx.data].map((item, i) => { + return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i)); + }); + return ParseStatus.mergeArray(status, result); + } + get element() { + return this._def.type; + } + min(minLength, message) { + return new _ZodArray({ + ...this._def, + minLength: { value: minLength, message: errorUtil.toString(message) } + }); + } + max(maxLength, message) { + return new _ZodArray({ + ...this._def, + maxLength: { value: maxLength, message: errorUtil.toString(message) } + }); + } + length(len, message) { + return new _ZodArray({ + ...this._def, + exactLength: { value: len, message: errorUtil.toString(message) } + }); + } + nonempty(message) { + return this.min(1, message); + } +}; +ZodArray.create = (schema, params) => { + return new ZodArray({ + type: schema, + minLength: null, + maxLength: null, + exactLength: null, + typeName: ZodFirstPartyTypeKind.ZodArray, + ...processCreateParams(params) + }); +}; +function deepPartialify(schema) { + if (schema instanceof ZodObject) { + const newShape = {}; + for (const key in schema.shape) { + const fieldSchema = schema.shape[key]; + newShape[key] = ZodOptional.create(deepPartialify(fieldSchema)); + } + return new ZodObject({ + ...schema._def, + shape: () => newShape + }); + } else if (schema instanceof ZodArray) { + return new ZodArray({ + ...schema._def, + type: deepPartialify(schema.element) + }); + } else if (schema instanceof ZodOptional) { + return ZodOptional.create(deepPartialify(schema.unwrap())); + } else if (schema instanceof ZodNullable) { + return ZodNullable.create(deepPartialify(schema.unwrap())); + } else if (schema instanceof ZodTuple) { + return ZodTuple.create(schema.items.map((item) => deepPartialify(item))); + } else { + return schema; + } +} +var ZodObject = class _ZodObject extends ZodType { + constructor() { + super(...arguments); + this._cached = null; + this.nonstrict = this.passthrough; + this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) + return this._cached; + const shape = this._def.shape(); + const keys = util.objectKeys(shape); + this._cached = { shape, keys }; + return this._cached; + } + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.object) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx2.parsedType + }); + return INVALID; + } + const { status, ctx } = this._processInputParams(input); + const { shape, keys: shapeKeys } = this._getCached(); + const extraKeys = []; + if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) { + for (const key in ctx.data) { + if (!shapeKeys.includes(key)) { + extraKeys.push(key); + } + } + } + const pairs = []; + for (const key of shapeKeys) { + const keyValidator = shape[key]; + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)), + alwaysSet: key in ctx.data + }); + } + if (this._def.catchall instanceof ZodNever) { + const unknownKeys = this._def.unknownKeys; + if (unknownKeys === "passthrough") { + for (const key of extraKeys) { + pairs.push({ + key: { status: "valid", value: key }, + value: { status: "valid", value: ctx.data[key] } + }); + } + } else if (unknownKeys === "strict") { + if (extraKeys.length > 0) { + addIssueToContext(ctx, { + code: ZodIssueCode.unrecognized_keys, + keys: extraKeys + }); + status.dirty(); + } + } else if (unknownKeys === "strip") { + } else { + throw new Error(`Internal ZodObject error: invalid unknownKeys value.`); + } + } else { + const catchall = this._def.catchall; + for (const key of extraKeys) { + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: catchall._parse( + new ParseInputLazyPath(ctx, value, ctx.path, key) + //, ctx.child(key), value, getParsedType(value) + ), + alwaysSet: key in ctx.data + }); + } + } + if (ctx.common.async) { + return Promise.resolve().then(async () => { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value, + alwaysSet: pair.alwaysSet + }); + } + return syncPairs; + }).then((syncPairs) => { + return ParseStatus.mergeObjectSync(status, syncPairs); + }); + } else { + return ParseStatus.mergeObjectSync(status, pairs); + } + } + get shape() { + return this._def.shape(); + } + strict(message) { + errorUtil.errToObj; + return new _ZodObject({ + ...this._def, + unknownKeys: "strict", + ...message !== void 0 ? { + errorMap: (issue2, ctx) => { + const defaultError = this._def.errorMap?.(issue2, ctx).message ?? ctx.defaultError; + if (issue2.code === "unrecognized_keys") + return { + message: errorUtil.errToObj(message).message ?? defaultError + }; + return { + message: defaultError + }; + } + } : {} + }); + } + strip() { + return new _ZodObject({ + ...this._def, + unknownKeys: "strip" + }); + } + passthrough() { + return new _ZodObject({ + ...this._def, + unknownKeys: "passthrough" + }); + } + // const AugmentFactory = + // (def: Def) => + // ( + // augmentation: Augmentation + // ): ZodObject< + // extendShape, Augmentation>, + // Def["unknownKeys"], + // Def["catchall"] + // > => { + // return new ZodObject({ + // ...def, + // shape: () => ({ + // ...def.shape(), + // ...augmentation, + // }), + // }) as any; + // }; + extend(augmentation) { + return new _ZodObject({ + ...this._def, + shape: () => ({ + ...this._def.shape(), + ...augmentation + }) + }); + } + /** + * Prior to zod@1.0.12 there was a bug in the + * inferred type of merged objects. Please + * upgrade if you are experiencing issues. + */ + merge(merging) { + const merged = new _ZodObject({ + unknownKeys: merging._def.unknownKeys, + catchall: merging._def.catchall, + shape: () => ({ + ...this._def.shape(), + ...merging._def.shape() + }), + typeName: ZodFirstPartyTypeKind.ZodObject + }); + return merged; + } + // merge< + // Incoming extends AnyZodObject, + // Augmentation extends Incoming["shape"], + // NewOutput extends { + // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation + // ? Augmentation[k]["_output"] + // : k extends keyof Output + // ? Output[k] + // : never; + // }, + // NewInput extends { + // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation + // ? Augmentation[k]["_input"] + // : k extends keyof Input + // ? Input[k] + // : never; + // } + // >( + // merging: Incoming + // ): ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"], + // NewOutput, + // NewInput + // > { + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + setKey(key, schema) { + return this.augment({ [key]: schema }); + } + // merge( + // merging: Incoming + // ): //ZodObject = (merging) => { + // ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"] + // > { + // // const mergedShape = objectUtil.mergeShapes( + // // this._def.shape(), + // // merging._def.shape() + // // ); + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + catchall(index) { + return new _ZodObject({ + ...this._def, + catchall: index + }); + } + pick(mask) { + const shape = {}; + for (const key of util.objectKeys(mask)) { + if (mask[key] && this.shape[key]) { + shape[key] = this.shape[key]; + } + } + return new _ZodObject({ + ...this._def, + shape: () => shape + }); + } + omit(mask) { + const shape = {}; + for (const key of util.objectKeys(this.shape)) { + if (!mask[key]) { + shape[key] = this.shape[key]; + } + } + return new _ZodObject({ + ...this._def, + shape: () => shape + }); + } + /** + * @deprecated + */ + deepPartial() { + return deepPartialify(this); + } + partial(mask) { + const newShape = {}; + for (const key of util.objectKeys(this.shape)) { + const fieldSchema = this.shape[key]; + if (mask && !mask[key]) { + newShape[key] = fieldSchema; + } else { + newShape[key] = fieldSchema.optional(); + } + } + return new _ZodObject({ + ...this._def, + shape: () => newShape + }); + } + required(mask) { + const newShape = {}; + for (const key of util.objectKeys(this.shape)) { + if (mask && !mask[key]) { + newShape[key] = this.shape[key]; + } else { + const fieldSchema = this.shape[key]; + let newField = fieldSchema; + while (newField instanceof ZodOptional) { + newField = newField._def.innerType; + } + newShape[key] = newField; + } + } + return new _ZodObject({ + ...this._def, + shape: () => newShape + }); + } + keyof() { + return createZodEnum(util.objectKeys(this.shape)); + } +}; +ZodObject.create = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); +}; +ZodObject.strictCreate = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strict", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); +}; +ZodObject.lazycreate = (shape, params) => { + return new ZodObject({ + shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); +}; +var ZodUnion = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const options = this._def.options; + function handleResults(results) { + for (const result of results) { + if (result.result.status === "valid") { + return result.result; + } + } + for (const result of results) { + if (result.result.status === "dirty") { + ctx.common.issues.push(...result.ctx.common.issues); + return result.result; + } + } + const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors + }); + return INVALID; + } + if (ctx.common.async) { + return Promise.all(options.map(async (option) => { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + return { + result: await option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }), + ctx: childCtx + }; + })).then(handleResults); + } else { + let dirty = void 0; + const issues = []; + for (const option of options) { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + const result = option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }); + if (result.status === "valid") { + return result; + } else if (result.status === "dirty" && !dirty) { + dirty = { result, ctx: childCtx }; + } + if (childCtx.common.issues.length) { + issues.push(childCtx.common.issues); + } + } + if (dirty) { + ctx.common.issues.push(...dirty.ctx.common.issues); + return dirty.result; + } + const unionErrors = issues.map((issues2) => new ZodError(issues2)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors + }); + return INVALID; + } + } + get options() { + return this._def.options; + } +}; +ZodUnion.create = (types, params) => { + return new ZodUnion({ + options: types, + typeName: ZodFirstPartyTypeKind.ZodUnion, + ...processCreateParams(params) + }); +}; +var getDiscriminator = (type) => { + if (type instanceof ZodLazy) { + return getDiscriminator(type.schema); + } else if (type instanceof ZodEffects) { + return getDiscriminator(type.innerType()); + } else if (type instanceof ZodLiteral) { + return [type.value]; + } else if (type instanceof ZodEnum) { + return type.options; + } else if (type instanceof ZodNativeEnum) { + return util.objectValues(type.enum); + } else if (type instanceof ZodDefault) { + return getDiscriminator(type._def.innerType); + } else if (type instanceof ZodUndefined) { + return [void 0]; + } else if (type instanceof ZodNull) { + return [null]; + } else if (type instanceof ZodOptional) { + return [void 0, ...getDiscriminator(type.unwrap())]; + } else if (type instanceof ZodNullable) { + return [null, ...getDiscriminator(type.unwrap())]; + } else if (type instanceof ZodBranded) { + return getDiscriminator(type.unwrap()); + } else if (type instanceof ZodReadonly) { + return getDiscriminator(type.unwrap()); + } else if (type instanceof ZodCatch) { + return getDiscriminator(type._def.innerType); + } else { + return []; + } +}; +var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType + }); + return INVALID; + } + const discriminator = this.discriminator; + const discriminatorValue = ctx.data[discriminator]; + const option = this.optionsMap.get(discriminatorValue); + if (!option) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union_discriminator, + options: Array.from(this.optionsMap.keys()), + path: [discriminator] + }); + return INVALID; + } + if (ctx.common.async) { + return option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } else { + return option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } + } + get discriminator() { + return this._def.discriminator; + } + get options() { + return this._def.options; + } + get optionsMap() { + return this._def.optionsMap; + } + /** + * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor. + * However, it only allows a union of objects, all of which need to share a discriminator property. This property must + * have a different value for each object in the union. + * @param discriminator the name of the discriminator property + * @param types an array of object schemas + * @param params + */ + static create(discriminator, options, params) { + const optionsMap = /* @__PURE__ */ new Map(); + for (const type of options) { + const discriminatorValues = getDiscriminator(type.shape[discriminator]); + if (!discriminatorValues.length) { + throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`); + } + for (const value of discriminatorValues) { + if (optionsMap.has(value)) { + throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`); + } + optionsMap.set(value, type); + } + } + return new _ZodDiscriminatedUnion({ + typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion, + discriminator, + options, + optionsMap, + ...processCreateParams(params) + }); + } +}; +function mergeValues(a, b) { + const aType = getParsedType(a); + const bType = getParsedType(b); + if (a === b) { + return { valid: true, data: a }; + } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) { + const bKeys = util.objectKeys(b); + const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a[key], b[key]); + if (!sharedValue.valid) { + return { valid: false }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) { + if (a.length !== b.length) { + return { valid: false }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues(itemA, itemB); + if (!sharedValue.valid) { + return { valid: false }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) { + return { valid: true, data: a }; + } else { + return { valid: false }; + } +} +var ZodIntersection = class extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const handleParsed = (parsedLeft, parsedRight) => { + if (isAborted(parsedLeft) || isAborted(parsedRight)) { + return INVALID; + } + const merged = mergeValues(parsedLeft.value, parsedRight.value); + if (!merged.valid) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_intersection_types + }); + return INVALID; + } + if (isDirty(parsedLeft) || isDirty(parsedRight)) { + status.dirty(); + } + return { status: status.value, value: merged.data }; + }; + if (ctx.common.async) { + return Promise.all([ + this._def.left._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), + this._def.right._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }) + ]).then(([left, right]) => handleParsed(left, right)); + } else { + return handleParsed(this._def.left._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), this._def.right._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + })); + } + } +}; +ZodIntersection.create = (left, right, params) => { + return new ZodIntersection({ + left, + right, + typeName: ZodFirstPartyTypeKind.ZodIntersection, + ...processCreateParams(params) + }); +}; +var ZodTuple = class _ZodTuple extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType + }); + return INVALID; + } + if (ctx.data.length < this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + return INVALID; + } + const rest = this._def.rest; + if (!rest && ctx.data.length > this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + status.dirty(); + } + const items = [...ctx.data].map((item, itemIndex) => { + const schema = this._def.items[itemIndex] || this._def.rest; + if (!schema) + return null; + return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex)); + }).filter((x) => !!x); + if (ctx.common.async) { + return Promise.all(items).then((results) => { + return ParseStatus.mergeArray(status, results); + }); + } else { + return ParseStatus.mergeArray(status, items); + } + } + get items() { + return this._def.items; + } + rest(rest) { + return new _ZodTuple({ + ...this._def, + rest + }); + } +}; +ZodTuple.create = (schemas, params) => { + if (!Array.isArray(schemas)) { + throw new Error("You must pass an array of schemas to z.tuple([ ... ])"); + } + return new ZodTuple({ + items: schemas, + typeName: ZodFirstPartyTypeKind.ZodTuple, + rest: null, + ...processCreateParams(params) + }); +}; +var ZodRecord = class _ZodRecord extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType + }); + return INVALID; + } + const pairs = []; + const keyType = this._def.keyType; + const valueType = this._def.valueType; + for (const key in ctx.data) { + pairs.push({ + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)), + value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)), + alwaysSet: key in ctx.data + }); + } + if (ctx.common.async) { + return ParseStatus.mergeObjectAsync(status, pairs); + } else { + return ParseStatus.mergeObjectSync(status, pairs); + } + } + get element() { + return this._def.valueType; + } + static create(first, second, third) { + if (second instanceof ZodType) { + return new _ZodRecord({ + keyType: first, + valueType: second, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(third) + }); + } + return new _ZodRecord({ + keyType: ZodString.create(), + valueType: first, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(second) + }); + } +}; +var ZodMap = class extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.map) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.map, + received: ctx.parsedType + }); + return INVALID; + } + const keyType = this._def.keyType; + const valueType = this._def.valueType; + const pairs = [...ctx.data.entries()].map(([key, value], index) => { + return { + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])), + value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])) + }; + }); + if (ctx.common.async) { + const finalMap = /* @__PURE__ */ new Map(); + return Promise.resolve().then(async () => { + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + }); + } else { + const finalMap = /* @__PURE__ */ new Map(); + for (const pair of pairs) { + const key = pair.key; + const value = pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + } + } +}; +ZodMap.create = (keyType, valueType, params) => { + return new ZodMap({ + valueType, + keyType, + typeName: ZodFirstPartyTypeKind.ZodMap, + ...processCreateParams(params) + }); +}; +var ZodSet = class _ZodSet extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.set) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.set, + received: ctx.parsedType + }); + return INVALID; + } + const def = this._def; + if (def.minSize !== null) { + if (ctx.data.size < def.minSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.minSize.message + }); + status.dirty(); + } + } + if (def.maxSize !== null) { + if (ctx.data.size > def.maxSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.maxSize.message + }); + status.dirty(); + } + } + const valueType = this._def.valueType; + function finalizeSet(elements2) { + const parsedSet = /* @__PURE__ */ new Set(); + for (const element of elements2) { + if (element.status === "aborted") + return INVALID; + if (element.status === "dirty") + status.dirty(); + parsedSet.add(element.value); + } + return { status: status.value, value: parsedSet }; + } + const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i))); + if (ctx.common.async) { + return Promise.all(elements).then((elements2) => finalizeSet(elements2)); + } else { + return finalizeSet(elements); + } + } + min(minSize, message) { + return new _ZodSet({ + ...this._def, + minSize: { value: minSize, message: errorUtil.toString(message) } + }); + } + max(maxSize, message) { + return new _ZodSet({ + ...this._def, + maxSize: { value: maxSize, message: errorUtil.toString(message) } + }); + } + size(size, message) { + return this.min(size, message).max(size, message); + } + nonempty(message) { + return this.min(1, message); + } +}; +ZodSet.create = (valueType, params) => { + return new ZodSet({ + valueType, + minSize: null, + maxSize: null, + typeName: ZodFirstPartyTypeKind.ZodSet, + ...processCreateParams(params) + }); +}; +var ZodFunction = class _ZodFunction extends ZodType { + constructor() { + super(...arguments); + this.validate = this.implement; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.function) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.function, + received: ctx.parsedType + }); + return INVALID; + } + function makeArgsIssue(args, error2) { + return makeIssue({ + data: args, + path: ctx.path, + errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_arguments, + argumentsError: error2 + } + }); + } + function makeReturnsIssue(returns, error2) { + return makeIssue({ + data: returns, + path: ctx.path, + errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_return_type, + returnTypeError: error2 + } + }); + } + const params = { errorMap: ctx.common.contextualErrorMap }; + const fn = ctx.data; + if (this._def.returns instanceof ZodPromise) { + const me = this; + return OK(async function(...args) { + const error2 = new ZodError([]); + const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => { + error2.addIssue(makeArgsIssue(args, e)); + throw error2; + }); + const result = await Reflect.apply(fn, this, parsedArgs); + const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => { + error2.addIssue(makeReturnsIssue(result, e)); + throw error2; + }); + return parsedReturns; + }); + } else { + const me = this; + return OK(function(...args) { + const parsedArgs = me._def.args.safeParse(args, params); + if (!parsedArgs.success) { + throw new ZodError([makeArgsIssue(args, parsedArgs.error)]); + } + const result = Reflect.apply(fn, this, parsedArgs.data); + const parsedReturns = me._def.returns.safeParse(result, params); + if (!parsedReturns.success) { + throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]); + } + return parsedReturns.data; + }); + } + } + parameters() { + return this._def.args; + } + returnType() { + return this._def.returns; + } + args(...items) { + return new _ZodFunction({ + ...this._def, + args: ZodTuple.create(items).rest(ZodUnknown.create()) + }); + } + returns(returnType) { + return new _ZodFunction({ + ...this._def, + returns: returnType + }); + } + implement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + strictImplement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + static create(args, returns, params) { + return new _ZodFunction({ + args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()), + returns: returns || ZodUnknown.create(), + typeName: ZodFirstPartyTypeKind.ZodFunction, + ...processCreateParams(params) + }); + } +}; +var ZodLazy = class extends ZodType { + get schema() { + return this._def.getter(); + } + _parse(input) { + const { ctx } = this._processInputParams(input); + const lazySchema = this._def.getter(); + return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx }); + } +}; +ZodLazy.create = (getter, params) => { + return new ZodLazy({ + getter, + typeName: ZodFirstPartyTypeKind.ZodLazy, + ...processCreateParams(params) + }); +}; +var ZodLiteral = class extends ZodType { + _parse(input) { + if (input.data !== this._def.value) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_literal, + expected: this._def.value + }); + return INVALID; + } + return { status: "valid", value: input.data }; + } + get value() { + return this._def.value; + } +}; +ZodLiteral.create = (value, params) => { + return new ZodLiteral({ + value, + typeName: ZodFirstPartyTypeKind.ZodLiteral, + ...processCreateParams(params) + }); +}; +function createZodEnum(values, params) { + return new ZodEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodEnum, + ...processCreateParams(params) + }); +} +var ZodEnum = class _ZodEnum extends ZodType { + _parse(input) { + if (typeof input.data !== "string") { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type + }); + return INVALID; + } + if (!this._cache) { + this._cache = new Set(this._def.values); + } + if (!this._cache.has(input.data)) { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues + }); + return INVALID; + } + return OK(input.data); + } + get options() { + return this._def.values; + } + get enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Values() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + extract(values, newDef = this._def) { + return _ZodEnum.create(values, { + ...this._def, + ...newDef + }); + } + exclude(values, newDef = this._def) { + return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), { + ...this._def, + ...newDef + }); + } +}; +ZodEnum.create = createZodEnum; +var ZodNativeEnum = class extends ZodType { + _parse(input) { + const nativeEnumValues = util.getValidEnumValues(this._def.values); + const ctx = this._getOrReturnCtx(input); + if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type + }); + return INVALID; + } + if (!this._cache) { + this._cache = new Set(util.getValidEnumValues(this._def.values)); + } + if (!this._cache.has(input.data)) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues + }); + return INVALID; + } + return OK(input.data); + } + get enum() { + return this._def.values; + } +}; +ZodNativeEnum.create = (values, params) => { + return new ZodNativeEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodNativeEnum, + ...processCreateParams(params) + }); +}; +var ZodPromise = class extends ZodType { + unwrap() { + return this._def.type; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.promise, + received: ctx.parsedType + }); + return INVALID; + } + const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data); + return OK(promisified.then((data) => { + return this._def.type.parseAsync(data, { + path: ctx.path, + errorMap: ctx.common.contextualErrorMap + }); + })); + } +}; +ZodPromise.create = (schema, params) => { + return new ZodPromise({ + type: schema, + typeName: ZodFirstPartyTypeKind.ZodPromise, + ...processCreateParams(params) + }); +}; +var ZodEffects = class extends ZodType { + innerType() { + return this._def.schema; + } + sourceType() { + return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const effect = this._def.effect || null; + const checkCtx = { + addIssue: (arg) => { + addIssueToContext(ctx, arg); + if (arg.fatal) { + status.abort(); + } else { + status.dirty(); + } + }, + get path() { + return ctx.path; + } + }; + checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx); + if (effect.type === "preprocess") { + const processed = effect.transform(ctx.data, checkCtx); + if (ctx.common.async) { + return Promise.resolve(processed).then(async (processed2) => { + if (status.value === "aborted") + return INVALID; + const result = await this._def.schema._parseAsync({ + data: processed2, + path: ctx.path, + parent: ctx + }); + if (result.status === "aborted") + return INVALID; + if (result.status === "dirty") + return DIRTY(result.value); + if (status.value === "dirty") + return DIRTY(result.value); + return result; + }); + } else { + if (status.value === "aborted") + return INVALID; + const result = this._def.schema._parseSync({ + data: processed, + path: ctx.path, + parent: ctx + }); + if (result.status === "aborted") + return INVALID; + if (result.status === "dirty") + return DIRTY(result.value); + if (status.value === "dirty") + return DIRTY(result.value); + return result; + } + } + if (effect.type === "refinement") { + const executeRefinement = (acc) => { + const result = effect.refinement(acc, checkCtx); + if (ctx.common.async) { + return Promise.resolve(result); + } + if (result instanceof Promise) { + throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead."); + } + return acc; + }; + if (ctx.common.async === false) { + const inner = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inner.status === "aborted") + return INVALID; + if (inner.status === "dirty") + status.dirty(); + executeRefinement(inner.value); + return { status: status.value, value: inner.value }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => { + if (inner.status === "aborted") + return INVALID; + if (inner.status === "dirty") + status.dirty(); + return executeRefinement(inner.value).then(() => { + return { status: status.value, value: inner.value }; + }); + }); + } + } + if (effect.type === "transform") { + if (ctx.common.async === false) { + const base = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (!isValid(base)) + return INVALID; + const result = effect.transform(base.value, checkCtx); + if (result instanceof Promise) { + throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`); + } + return { status: status.value, value: result }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => { + if (!isValid(base)) + return INVALID; + return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ + status: status.value, + value: result + })); + }); + } + } + util.assertNever(effect); + } +}; +ZodEffects.create = (schema, effect, params) => { + return new ZodEffects({ + schema, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect, + ...processCreateParams(params) + }); +}; +ZodEffects.createWithPreprocess = (preprocess2, schema, params) => { + return new ZodEffects({ + schema, + effect: { type: "preprocess", transform: preprocess2 }, + typeName: ZodFirstPartyTypeKind.ZodEffects, + ...processCreateParams(params) + }); +}; +var ZodOptional = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 === ZodParsedType.undefined) { + return OK(void 0); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } +}; +ZodOptional.create = (type, params) => { + return new ZodOptional({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodOptional, + ...processCreateParams(params) + }); +}; +var ZodNullable = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 === ZodParsedType.null) { + return OK(null); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } +}; +ZodNullable.create = (type, params) => { + return new ZodNullable({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodNullable, + ...processCreateParams(params) + }); +}; +var ZodDefault = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + let data = ctx.data; + if (ctx.parsedType === ZodParsedType.undefined) { + data = this._def.defaultValue(); + } + return this._def.innerType._parse({ + data, + path: ctx.path, + parent: ctx + }); + } + removeDefault() { + return this._def.innerType; + } +}; +ZodDefault.create = (type, params) => { + return new ZodDefault({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodDefault, + defaultValue: typeof params.default === "function" ? params.default : () => params.default, + ...processCreateParams(params) + }); +}; +var ZodCatch = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const newCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + } + }; + const result = this._def.innerType._parse({ + data: newCtx.data, + path: newCtx.path, + parent: { + ...newCtx + } + }); + if (isAsync(result)) { + return result.then((result2) => { + return { + status: "valid", + value: result2.status === "valid" ? result2.value : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + }); + } else { + return { + status: "valid", + value: result.status === "valid" ? result.value : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + } + } + removeCatch() { + return this._def.innerType; + } +}; +ZodCatch.create = (type, params) => { + return new ZodCatch({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodCatch, + catchValue: typeof params.catch === "function" ? params.catch : () => params.catch, + ...processCreateParams(params) + }); +}; +var ZodNaN = class extends ZodType { + _parse(input) { + const parsedType2 = this._getType(input); + if (parsedType2 !== ZodParsedType.nan) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.nan, + received: ctx.parsedType + }); + return INVALID; + } + return { status: "valid", value: input.data }; + } +}; +ZodNaN.create = (params) => { + return new ZodNaN({ + typeName: ZodFirstPartyTypeKind.ZodNaN, + ...processCreateParams(params) + }); +}; +var BRAND = Symbol("zod_brand"); +var ZodBranded = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const data = ctx.data; + return this._def.type._parse({ + data, + path: ctx.path, + parent: ctx + }); + } + unwrap() { + return this._def.type; + } +}; +var ZodPipeline = class _ZodPipeline extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.common.async) { + const handleAsync = async () => { + const inResult = await this._def.in._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID; + if (inResult.status === "dirty") { + status.dirty(); + return DIRTY(inResult.value); + } else { + return this._def.out._parseAsync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + }; + return handleAsync(); + } else { + const inResult = this._def.in._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID; + if (inResult.status === "dirty") { + status.dirty(); + return { + status: "dirty", + value: inResult.value + }; + } else { + return this._def.out._parseSync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + } + } + static create(a, b) { + return new _ZodPipeline({ + in: a, + out: b, + typeName: ZodFirstPartyTypeKind.ZodPipeline + }); + } +}; +var ZodReadonly = class extends ZodType { + _parse(input) { + const result = this._def.innerType._parse(input); + const freeze = (data) => { + if (isValid(data)) { + data.value = Object.freeze(data.value); + } + return data; + }; + return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result); + } + unwrap() { + return this._def.innerType; + } +}; +ZodReadonly.create = (type, params) => { + return new ZodReadonly({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodReadonly, + ...processCreateParams(params) + }); +}; +var late = { + object: ZodObject.lazycreate +}; +var ZodFirstPartyTypeKind; +(function(ZodFirstPartyTypeKind3) { + ZodFirstPartyTypeKind3["ZodString"] = "ZodString"; + ZodFirstPartyTypeKind3["ZodNumber"] = "ZodNumber"; + ZodFirstPartyTypeKind3["ZodNaN"] = "ZodNaN"; + ZodFirstPartyTypeKind3["ZodBigInt"] = "ZodBigInt"; + ZodFirstPartyTypeKind3["ZodBoolean"] = "ZodBoolean"; + ZodFirstPartyTypeKind3["ZodDate"] = "ZodDate"; + ZodFirstPartyTypeKind3["ZodSymbol"] = "ZodSymbol"; + ZodFirstPartyTypeKind3["ZodUndefined"] = "ZodUndefined"; + ZodFirstPartyTypeKind3["ZodNull"] = "ZodNull"; + ZodFirstPartyTypeKind3["ZodAny"] = "ZodAny"; + ZodFirstPartyTypeKind3["ZodUnknown"] = "ZodUnknown"; + ZodFirstPartyTypeKind3["ZodNever"] = "ZodNever"; + ZodFirstPartyTypeKind3["ZodVoid"] = "ZodVoid"; + ZodFirstPartyTypeKind3["ZodArray"] = "ZodArray"; + ZodFirstPartyTypeKind3["ZodObject"] = "ZodObject"; + ZodFirstPartyTypeKind3["ZodUnion"] = "ZodUnion"; + ZodFirstPartyTypeKind3["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion"; + ZodFirstPartyTypeKind3["ZodIntersection"] = "ZodIntersection"; + ZodFirstPartyTypeKind3["ZodTuple"] = "ZodTuple"; + ZodFirstPartyTypeKind3["ZodRecord"] = "ZodRecord"; + ZodFirstPartyTypeKind3["ZodMap"] = "ZodMap"; + ZodFirstPartyTypeKind3["ZodSet"] = "ZodSet"; + ZodFirstPartyTypeKind3["ZodFunction"] = "ZodFunction"; + ZodFirstPartyTypeKind3["ZodLazy"] = "ZodLazy"; + ZodFirstPartyTypeKind3["ZodLiteral"] = "ZodLiteral"; + ZodFirstPartyTypeKind3["ZodEnum"] = "ZodEnum"; + ZodFirstPartyTypeKind3["ZodEffects"] = "ZodEffects"; + ZodFirstPartyTypeKind3["ZodNativeEnum"] = "ZodNativeEnum"; + ZodFirstPartyTypeKind3["ZodOptional"] = "ZodOptional"; + ZodFirstPartyTypeKind3["ZodNullable"] = "ZodNullable"; + ZodFirstPartyTypeKind3["ZodDefault"] = "ZodDefault"; + ZodFirstPartyTypeKind3["ZodCatch"] = "ZodCatch"; + ZodFirstPartyTypeKind3["ZodPromise"] = "ZodPromise"; + ZodFirstPartyTypeKind3["ZodBranded"] = "ZodBranded"; + ZodFirstPartyTypeKind3["ZodPipeline"] = "ZodPipeline"; + ZodFirstPartyTypeKind3["ZodReadonly"] = "ZodReadonly"; +})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {})); +var stringType = ZodString.create; +var numberType = ZodNumber.create; +var nanType = ZodNaN.create; +var bigIntType = ZodBigInt.create; +var booleanType = ZodBoolean.create; +var dateType = ZodDate.create; +var symbolType = ZodSymbol.create; +var undefinedType = ZodUndefined.create; +var nullType = ZodNull.create; +var anyType = ZodAny.create; +var unknownType = ZodUnknown.create; +var neverType = ZodNever.create; +var voidType = ZodVoid.create; +var arrayType = ZodArray.create; +var objectType = ZodObject.create; +var strictObjectType = ZodObject.strictCreate; +var unionType = ZodUnion.create; +var discriminatedUnionType = ZodDiscriminatedUnion.create; +var intersectionType = ZodIntersection.create; +var tupleType = ZodTuple.create; +var recordType = ZodRecord.create; +var mapType = ZodMap.create; +var setType = ZodSet.create; +var functionType = ZodFunction.create; +var lazyType = ZodLazy.create; +var literalType = ZodLiteral.create; +var enumType = ZodEnum.create; +var nativeEnumType = ZodNativeEnum.create; +var promiseType = ZodPromise.create; +var effectsType = ZodEffects.create; +var optionalType = ZodOptional.create; +var nullableType = ZodNullable.create; +var preprocessType = ZodEffects.createWithPreprocess; +var pipelineType = ZodPipeline.create; + +// node_modules/zod/v4/core/core.js +var NEVER = Object.freeze({ + status: "aborted" +}); +// @__NO_SIDE_EFFECTS__ +function $constructor(name, initializer3, params) { + function init(inst, def) { + if (!inst._zod) { + Object.defineProperty(inst, "_zod", { + value: { + def, + constr: _, + traits: /* @__PURE__ */ new Set() + }, + enumerable: false + }); + } + if (inst._zod.traits.has(name)) { + return; + } + inst._zod.traits.add(name); + initializer3(inst, def); + const proto = _.prototype; + const keys = Object.keys(proto); + for (let i = 0; i < keys.length; i++) { + const k = keys[i]; + if (!(k in inst)) { + inst[k] = proto[k].bind(inst); + } + } + } + const Parent = params?.Parent ?? Object; + class Definition extends Parent { + } + Object.defineProperty(Definition, "name", { value: name }); + function _(def) { + var _a2; + const inst = params?.Parent ? new Definition() : this; + init(inst, def); + (_a2 = inst._zod).deferred ?? (_a2.deferred = []); + for (const fn of inst._zod.deferred) { + fn(); + } + return inst; + } + Object.defineProperty(_, "init", { value: init }); + Object.defineProperty(_, Symbol.hasInstance, { + value: (inst) => { + if (params?.Parent && inst instanceof params.Parent) + return true; + return inst?._zod?.traits?.has(name); + } + }); + Object.defineProperty(_, "name", { value: name }); + return _; +} +var $brand = Symbol("zod_brand"); +var $ZodAsyncError = class extends Error { + constructor() { + super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`); + } +}; +var $ZodEncodeError = class extends Error { + constructor(name) { + super(`Encountered unidirectional transform during encode: ${name}`); + this.name = "ZodEncodeError"; + } +}; +var globalConfig = {}; +function config(newConfig) { + if (newConfig) + Object.assign(globalConfig, newConfig); + return globalConfig; +} + +// node_modules/zod/v4/core/util.js +var util_exports = {}; +__export(util_exports, { + BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES, + Class: () => Class, + NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES, + aborted: () => aborted, + allowsEval: () => allowsEval, + assert: () => assert, + assertEqual: () => assertEqual, + assertIs: () => assertIs, + assertNever: () => assertNever, + assertNotEqual: () => assertNotEqual, + assignProp: () => assignProp, + base64ToUint8Array: () => base64ToUint8Array, + base64urlToUint8Array: () => base64urlToUint8Array, + cached: () => cached, + captureStackTrace: () => captureStackTrace, + cleanEnum: () => cleanEnum, + cleanRegex: () => cleanRegex, + clone: () => clone, + cloneDef: () => cloneDef, + createTransparentProxy: () => createTransparentProxy, + defineLazy: () => defineLazy, + esc: () => esc, + escapeRegex: () => escapeRegex, + extend: () => extend, + finalizeIssue: () => finalizeIssue, + floatSafeRemainder: () => floatSafeRemainder2, + getElementAtPath: () => getElementAtPath, + getEnumValues: () => getEnumValues, + getLengthableOrigin: () => getLengthableOrigin, + getParsedType: () => getParsedType2, + getSizableOrigin: () => getSizableOrigin, + hexToUint8Array: () => hexToUint8Array, + isObject: () => isObject, + isPlainObject: () => isPlainObject, + issue: () => issue, + joinValues: () => joinValues, + jsonStringifyReplacer: () => jsonStringifyReplacer, + merge: () => merge, + mergeDefs: () => mergeDefs, + normalizeParams: () => normalizeParams, + nullish: () => nullish, + numKeys: () => numKeys, + objectClone: () => objectClone, + omit: () => omit, + optionalKeys: () => optionalKeys, + parsedType: () => parsedType, + partial: () => partial, + pick: () => pick, + prefixIssues: () => prefixIssues, + primitiveTypes: () => primitiveTypes, + promiseAllObject: () => promiseAllObject, + propertyKeyTypes: () => propertyKeyTypes, + randomString: () => randomString, + required: () => required, + safeExtend: () => safeExtend, + shallowClone: () => shallowClone, + slugify: () => slugify, + stringifyPrimitive: () => stringifyPrimitive, + uint8ArrayToBase64: () => uint8ArrayToBase64, + uint8ArrayToBase64url: () => uint8ArrayToBase64url, + uint8ArrayToHex: () => uint8ArrayToHex, + unwrapMessage: () => unwrapMessage +}); +function assertEqual(val) { + return val; +} +function assertNotEqual(val) { + return val; +} +function assertIs(_arg) { +} +function assertNever(_x) { + throw new Error("Unexpected value in exhaustive check"); +} +function assert(_) { +} +function getEnumValues(entries) { + const numericValues = Object.values(entries).filter((v) => typeof v === "number"); + const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v); + return values; +} +function joinValues(array2, separator = "|") { + return array2.map((val) => stringifyPrimitive(val)).join(separator); +} +function jsonStringifyReplacer(_, value) { + if (typeof value === "bigint") + return value.toString(); + return value; +} +function cached(getter) { + const set2 = false; + return { + get value() { + if (!set2) { + const value = getter(); + Object.defineProperty(this, "value", { value }); + return value; + } + throw new Error("cached value already set"); + } + }; +} +function nullish(input) { + return input === null || input === void 0; +} +function cleanRegex(source) { + const start = source.startsWith("^") ? 1 : 0; + const end = source.endsWith("$") ? source.length - 1 : source.length; + return source.slice(start, end); +} +function floatSafeRemainder2(val, step) { + const valDecCount = (val.toString().split(".")[1] || "").length; + const stepString = step.toString(); + let stepDecCount = (stepString.split(".")[1] || "").length; + if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) { + const match = stepString.match(/\d?e-(\d?)/); + if (match?.[1]) { + stepDecCount = Number.parseInt(match[1]); + } + } + const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; + const valInt = Number.parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", "")); + return valInt % stepInt / 10 ** decCount; +} +var EVALUATING = Symbol("evaluating"); +function defineLazy(object3, key, getter) { + let value = void 0; + Object.defineProperty(object3, key, { + get() { + if (value === EVALUATING) { + return void 0; + } + if (value === void 0) { + value = EVALUATING; + value = getter(); + } + return value; + }, + set(v) { + Object.defineProperty(object3, key, { + value: v + // configurable: true, + }); + }, + configurable: true + }); +} +function objectClone(obj) { + return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)); +} +function assignProp(target, prop, value) { + Object.defineProperty(target, prop, { + value, + writable: true, + enumerable: true, + configurable: true + }); +} +function mergeDefs(...defs) { + const mergedDescriptors = {}; + for (const def of defs) { + const descriptors = Object.getOwnPropertyDescriptors(def); + Object.assign(mergedDescriptors, descriptors); + } + return Object.defineProperties({}, mergedDescriptors); +} +function cloneDef(schema) { + return mergeDefs(schema._zod.def); +} +function getElementAtPath(obj, path3) { + if (!path3) + return obj; + return path3.reduce((acc, key) => acc?.[key], obj); +} +function promiseAllObject(promisesObj) { + const keys = Object.keys(promisesObj); + const promises = keys.map((key) => promisesObj[key]); + return Promise.all(promises).then((results) => { + const resolvedObj = {}; + for (let i = 0; i < keys.length; i++) { + resolvedObj[keys[i]] = results[i]; + } + return resolvedObj; + }); +} +function randomString(length = 10) { + const chars = "abcdefghijklmnopqrstuvwxyz"; + let str = ""; + for (let i = 0; i < length; i++) { + str += chars[Math.floor(Math.random() * chars.length)]; + } + return str; +} +function esc(str) { + return JSON.stringify(str); +} +function slugify(input) { + return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, ""); +} +var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { +}; +function isObject(data) { + return typeof data === "object" && data !== null && !Array.isArray(data); +} +var allowsEval = cached(() => { + if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) { + return false; + } + try { + const F = Function; + new F(""); + return true; + } catch (_) { + return false; + } +}); +function isPlainObject(o) { + if (isObject(o) === false) + return false; + const ctor = o.constructor; + if (ctor === void 0) + return true; + if (typeof ctor !== "function") + return true; + const prot = ctor.prototype; + if (isObject(prot) === false) + return false; + if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) { + return false; + } + return true; +} +function shallowClone(o) { + if (isPlainObject(o)) + return { ...o }; + if (Array.isArray(o)) + return [...o]; + return o; +} +function numKeys(data) { + let keyCount = 0; + for (const key in data) { + if (Object.prototype.hasOwnProperty.call(data, key)) { + keyCount++; + } + } + return keyCount; +} +var getParsedType2 = (data) => { + const t = typeof data; + switch (t) { + case "undefined": + return "undefined"; + case "string": + return "string"; + case "number": + return Number.isNaN(data) ? "nan" : "number"; + case "boolean": + return "boolean"; + case "function": + return "function"; + case "bigint": + return "bigint"; + case "symbol": + return "symbol"; + case "object": + if (Array.isArray(data)) { + return "array"; + } + if (data === null) { + return "null"; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return "promise"; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return "map"; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return "set"; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return "date"; + } + if (typeof File !== "undefined" && data instanceof File) { + return "file"; + } + return "object"; + default: + throw new Error(`Unknown data type: ${t}`); + } +}; +var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]); +var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]); +function escapeRegex(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function clone(inst, def, params) { + const cl = new inst._zod.constr(def ?? inst._zod.def); + if (!def || params?.parent) + cl._zod.parent = inst; + return cl; +} +function normalizeParams(_params) { + const params = _params; + if (!params) + return {}; + if (typeof params === "string") + return { error: () => params }; + if (params?.message !== void 0) { + if (params?.error !== void 0) + throw new Error("Cannot specify both `message` and `error` params"); + params.error = params.message; + } + delete params.message; + if (typeof params.error === "string") + return { ...params, error: () => params.error }; + return params; +} +function createTransparentProxy(getter) { + let target; + return new Proxy({}, { + get(_, prop, receiver) { + target ?? (target = getter()); + return Reflect.get(target, prop, receiver); + }, + set(_, prop, value, receiver) { + target ?? (target = getter()); + return Reflect.set(target, prop, value, receiver); + }, + has(_, prop) { + target ?? (target = getter()); + return Reflect.has(target, prop); + }, + deleteProperty(_, prop) { + target ?? (target = getter()); + return Reflect.deleteProperty(target, prop); + }, + ownKeys(_) { + target ?? (target = getter()); + return Reflect.ownKeys(target); + }, + getOwnPropertyDescriptor(_, prop) { + target ?? (target = getter()); + return Reflect.getOwnPropertyDescriptor(target, prop); + }, + defineProperty(_, prop, descriptor) { + target ?? (target = getter()); + return Reflect.defineProperty(target, prop, descriptor); + } + }); +} +function stringifyPrimitive(value) { + if (typeof value === "bigint") + return value.toString() + "n"; + if (typeof value === "string") + return `"${value}"`; + return `${value}`; +} +function optionalKeys(shape) { + return Object.keys(shape).filter((k) => { + return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional"; + }); +} +var NUMBER_FORMAT_RANGES = { + safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], + int32: [-2147483648, 2147483647], + uint32: [0, 4294967295], + float32: [-34028234663852886e22, 34028234663852886e22], + float64: [-Number.MAX_VALUE, Number.MAX_VALUE] +}; +var BIGINT_FORMAT_RANGES = { + int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")], + uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")] +}; +function pick(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".pick() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = {}; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + newShape[key] = currDef.shape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function omit(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".omit() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = { ...schema._zod.def.shape }; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + delete newShape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function extend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to extend: expected a plain object"); + } + const checks = schema._zod.def.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + const existingShape = schema._zod.def.shape; + for (const key in shape) { + if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) { + throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead."); + } + } + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function safeExtend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to safeExtend: expected a plain object"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function merge(a, b) { + const def = mergeDefs(a._zod.def, { + get shape() { + const _shape = { ...a._zod.def.shape, ...b._zod.def.shape }; + assignProp(this, "shape", _shape); + return _shape; + }, + get catchall() { + return b._zod.def.catchall; + }, + checks: [] + // delete existing checks + }); + return clone(a, def); +} +function partial(Class2, schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".partial() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in oldShape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } else { + for (const key in oldShape) { + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } + assignProp(this, "shape", shape); + return shape; + }, + checks: [] + }); + return clone(schema, def); +} +function required(Class2, schema, mask) { + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } else { + for (const key in oldShape) { + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } + assignProp(this, "shape", shape); + return shape; + } + }); + return clone(schema, def); +} +function aborted(x, startIndex = 0) { + if (x.aborted === true) + return true; + for (let i = startIndex; i < x.issues.length; i++) { + if (x.issues[i]?.continue !== true) { + return true; + } + } + return false; +} +function prefixIssues(path3, issues) { + return issues.map((iss) => { + var _a2; + (_a2 = iss).path ?? (_a2.path = []); + iss.path.unshift(path3); + return iss; + }); +} +function unwrapMessage(message) { + return typeof message === "string" ? message : message?.message; +} +function finalizeIssue(iss, ctx, config3) { + const full = { ...iss, path: iss.path ?? [] }; + if (!iss.message) { + const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config3.customError?.(iss)) ?? unwrapMessage(config3.localeError?.(iss)) ?? "Invalid input"; + full.message = message; + } + delete full.inst; + delete full.continue; + if (!ctx?.reportInput) { + delete full.input; + } + return full; +} +function getSizableOrigin(input) { + if (input instanceof Set) + return "set"; + if (input instanceof Map) + return "map"; + if (input instanceof File) + return "file"; + return "unknown"; +} +function getLengthableOrigin(input) { + if (Array.isArray(input)) + return "array"; + if (typeof input === "string") + return "string"; + return "unknown"; +} +function parsedType(data) { + const t = typeof data; + switch (t) { + case "number": { + return Number.isNaN(data) ? "nan" : "number"; + } + case "object": { + if (data === null) { + return "null"; + } + if (Array.isArray(data)) { + return "array"; + } + const obj = data; + if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) { + return obj.constructor.name; + } + } + } + return t; +} +function issue(...args) { + const [iss, input, inst] = args; + if (typeof iss === "string") { + return { + message: iss, + code: "custom", + input, + inst + }; + } + return { ...iss }; +} +function cleanEnum(obj) { + return Object.entries(obj).filter(([k, _]) => { + return Number.isNaN(Number.parseInt(k, 10)); + }).map((el) => el[1]); +} +function base64ToUint8Array(base643) { + const binaryString = atob(base643); + const bytes = new Uint8Array(binaryString.length); + for (let i = 0; i < binaryString.length; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return bytes; +} +function uint8ArrayToBase64(bytes) { + let binaryString = ""; + for (let i = 0; i < bytes.length; i++) { + binaryString += String.fromCharCode(bytes[i]); + } + return btoa(binaryString); +} +function base64urlToUint8Array(base64url3) { + const base643 = base64url3.replace(/-/g, "+").replace(/_/g, "/"); + const padding = "=".repeat((4 - base643.length % 4) % 4); + return base64ToUint8Array(base643 + padding); +} +function uint8ArrayToBase64url(bytes) { + return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); +} +function hexToUint8Array(hex3) { + const cleanHex = hex3.replace(/^0x/, ""); + if (cleanHex.length % 2 !== 0) { + throw new Error("Invalid hex string length"); + } + const bytes = new Uint8Array(cleanHex.length / 2); + for (let i = 0; i < cleanHex.length; i += 2) { + bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16); + } + return bytes; +} +function uint8ArrayToHex(bytes) { + return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""); +} +var Class = class { + constructor(..._args) { + } +}; + +// node_modules/zod/v4/core/errors.js +var initializer = (inst, def) => { + inst.name = "$ZodError"; + Object.defineProperty(inst, "_zod", { + value: inst._zod, + enumerable: false + }); + Object.defineProperty(inst, "issues", { + value: def, + enumerable: false + }); + inst.message = JSON.stringify(def, jsonStringifyReplacer, 2); + Object.defineProperty(inst, "toString", { + value: () => inst.message, + enumerable: false + }); +}; +var $ZodError = $constructor("$ZodError", initializer); +var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error }); +function flattenError(error2, mapper = (issue2) => issue2.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of error2.issues) { + if (sub.path.length > 0) { + fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || []; + fieldErrors[sub.path[0]].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; +} +function formatError(error2, mapper = (issue2) => issue2.message) { + const fieldErrors = { _errors: [] }; + const processError = (error3) => { + for (const issue2 of error3.issues) { + if (issue2.code === "invalid_union" && issue2.errors.length) { + issue2.errors.map((issues) => processError({ issues })); + } else if (issue2.code === "invalid_key") { + processError({ issues: issue2.issues }); + } else if (issue2.code === "invalid_element") { + processError({ issues: issue2.issues }); + } else if (issue2.path.length === 0) { + fieldErrors._errors.push(mapper(issue2)); + } else { + let curr = fieldErrors; + let i = 0; + while (i < issue2.path.length) { + const el = issue2.path[i]; + const terminal = i === issue2.path.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue2)); + } + curr = curr[el]; + i++; + } + } + } + }; + processError(error2); + return fieldErrors; +} + +// node_modules/zod/v4/core/parse.js +var _parse = (_Err) => (schema, value, _ctx, _params) => { + const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + if (result.issues.length) { + const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, _params?.callee); + throw e; + } + return result.value; +}; +var parse = /* @__PURE__ */ _parse($ZodRealError); +var _parseAsync = (_Err) => async (schema, value, _ctx, params) => { + const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + if (result.issues.length) { + const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, params?.callee); + throw e; + } + return result.value; +}; +var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError); +var _safeParse = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, async: false } : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + return result.issues.length ? { + success: false, + error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParse = /* @__PURE__ */ _safeParse($ZodRealError); +var _safeParseAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + return result.issues.length ? { + success: false, + error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError); +var _encode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _parse(_Err)(schema, value, ctx); +}; +var _decode = (_Err) => (schema, value, _ctx) => { + return _parse(_Err)(schema, value, _ctx); +}; +var _encodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _parseAsync(_Err)(schema, value, ctx); +}; +var _decodeAsync = (_Err) => async (schema, value, _ctx) => { + return _parseAsync(_Err)(schema, value, _ctx); +}; +var _safeEncode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _safeParse(_Err)(schema, value, ctx); +}; +var _safeDecode = (_Err) => (schema, value, _ctx) => { + return _safeParse(_Err)(schema, value, _ctx); +}; +var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" }; + return _safeParseAsync(_Err)(schema, value, ctx); +}; +var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => { + return _safeParseAsync(_Err)(schema, value, _ctx); +}; + +// node_modules/zod/v4/core/regexes.js +var regexes_exports = {}; +__export(regexes_exports, { + base64: () => base64, + base64url: () => base64url, + bigint: () => bigint, + boolean: () => boolean, + browserEmail: () => browserEmail, + cidrv4: () => cidrv4, + cidrv6: () => cidrv6, + cuid: () => cuid, + cuid2: () => cuid2, + date: () => date, + datetime: () => datetime, + domain: () => domain, + duration: () => duration, + e164: () => e164, + email: () => email, + emoji: () => emoji, + extendedDuration: () => extendedDuration, + guid: () => guid, + hex: () => hex, + hostname: () => hostname, + html5Email: () => html5Email, + idnEmail: () => idnEmail, + integer: () => integer, + ipv4: () => ipv4, + ipv6: () => ipv6, + ksuid: () => ksuid, + lowercase: () => lowercase, + mac: () => mac, + md5_base64: () => md5_base64, + md5_base64url: () => md5_base64url, + md5_hex: () => md5_hex, + nanoid: () => nanoid, + null: () => _null, + number: () => number, + rfc5322Email: () => rfc5322Email, + sha1_base64: () => sha1_base64, + sha1_base64url: () => sha1_base64url, + sha1_hex: () => sha1_hex, + sha256_base64: () => sha256_base64, + sha256_base64url: () => sha256_base64url, + sha256_hex: () => sha256_hex, + sha384_base64: () => sha384_base64, + sha384_base64url: () => sha384_base64url, + sha384_hex: () => sha384_hex, + sha512_base64: () => sha512_base64, + sha512_base64url: () => sha512_base64url, + sha512_hex: () => sha512_hex, + string: () => string, + time: () => time, + ulid: () => ulid, + undefined: () => _undefined, + unicodeEmail: () => unicodeEmail, + uppercase: () => uppercase, + uuid: () => uuid, + uuid4: () => uuid4, + uuid6: () => uuid6, + uuid7: () => uuid7, + xid: () => xid +}); +var cuid = /^[cC][^\s-]{8,}$/; +var cuid2 = /^[0-9a-z]+$/; +var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/; +var xid = /^[0-9a-vA-V]{20}$/; +var ksuid = /^[A-Za-z0-9]{27}$/; +var nanoid = /^[a-zA-Z0-9_-]{21}$/; +var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/; +var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/; +var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/; +var uuid = (version2) => { + if (!version2) + return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/; + return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`); +}; +var uuid4 = /* @__PURE__ */ uuid(4); +var uuid6 = /* @__PURE__ */ uuid(6); +var uuid7 = /* @__PURE__ */ uuid(7); +var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/; +var html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/; +var rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; +var unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u; +var idnEmail = unicodeEmail; +var browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/; +var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +function emoji() { + return new RegExp(_emoji, "u"); +} +var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; +var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/; +var mac = (delimiter) => { + const escapedDelim = escapeRegex(delimiter ?? ":"); + return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`); +}; +var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/; +var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/; +var base64url = /^[A-Za-z0-9_-]*$/; +var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/; +var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/; +var e164 = /^\+[1-9]\d{6,14}$/; +var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`; +var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`); +function timeSource(args) { + const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`; + 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 time3 = timeSource({ precision: args.precision }); + const opts = ["Z"]; + if (args.local) + opts.push(""); + if (args.offset) + opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`); + const timeRegex2 = `${time3}(?:${opts.join("|")})`; + return new RegExp(`^${dateSource}T(?:${timeRegex2})$`); +} +var string = (params) => { + const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`; + return new RegExp(`^${regex}$`); +}; +var bigint = /^-?\d+n?$/; +var integer = /^-?\d+$/; +var number = /^-?\d+(?:\.\d+)?$/; +var boolean = /^(?:true|false)$/i; +var _null = /^null$/i; +var _undefined = /^undefined$/i; +var lowercase = /^[^A-Z]*$/; +var uppercase = /^[^a-z]*$/; +var hex = /^[0-9a-fA-F]*$/; +function fixedBase64(bodyLength, padding) { + return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`); +} +function fixedBase64url(length) { + return new RegExp(`^[A-Za-z0-9_-]{${length}}$`); +} +var md5_hex = /^[0-9a-fA-F]{32}$/; +var md5_base64 = /* @__PURE__ */ fixedBase64(22, "=="); +var md5_base64url = /* @__PURE__ */ fixedBase64url(22); +var sha1_hex = /^[0-9a-fA-F]{40}$/; +var sha1_base64 = /* @__PURE__ */ fixedBase64(27, "="); +var sha1_base64url = /* @__PURE__ */ fixedBase64url(27); +var sha256_hex = /^[0-9a-fA-F]{64}$/; +var sha256_base64 = /* @__PURE__ */ fixedBase64(43, "="); +var sha256_base64url = /* @__PURE__ */ fixedBase64url(43); +var sha384_hex = /^[0-9a-fA-F]{96}$/; +var sha384_base64 = /* @__PURE__ */ fixedBase64(64, ""); +var sha384_base64url = /* @__PURE__ */ fixedBase64url(64); +var sha512_hex = /^[0-9a-fA-F]{128}$/; +var sha512_base64 = /* @__PURE__ */ fixedBase64(86, "=="); +var sha512_base64url = /* @__PURE__ */ fixedBase64url(86); + +// node_modules/zod/v4/core/checks.js +var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => { + var _a2; + inst._zod ?? (inst._zod = {}); + inst._zod.def = def; + (_a2 = inst._zod).onattach ?? (_a2.onattach = []); +}); +var numericOriginMap = { + number: "number", + bigint: "bigint", + object: "date" +}; +var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY; + if (def.value < curr) { + if (def.inclusive) + bag.maximum = def.value; + else + bag.exclusiveMaximum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value <= def.value : payload.value < def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_big", + maximum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY; + if (def.value > curr) { + if (def.inclusive) + bag.minimum = def.value; + else + bag.exclusiveMinimum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value >= def.value : payload.value > def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_small", + minimum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + var _a2; + (_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value); + }); + inst._zod.check = (payload) => { + if (typeof payload.value !== typeof def.value) + throw new Error("Cannot mix number and bigint in multiple_of check."); + const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder2(payload.value, def.value) === 0; + if (isMultiple) + return; + payload.issues.push({ + origin: typeof payload.value, + code: "not_multiple_of", + divisor: def.value, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => { + $ZodCheck.init(inst, def); + def.format = def.format || "float64"; + const isInt = def.format?.includes("int"); + const origin = isInt ? "int" : "number"; + const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + bag.minimum = minimum; + bag.maximum = maximum; + if (isInt) + bag.pattern = integer; + }); + inst._zod.check = (payload) => { + const input = payload.value; + if (isInt) { + if (!Number.isInteger(input)) { + payload.issues.push({ + expected: origin, + format: def.format, + code: "invalid_type", + continue: false, + input, + inst + }); + return; + } + if (!Number.isSafeInteger(input)) { + if (input > 0) { + payload.issues.push({ + input, + code: "too_big", + maximum: Number.MAX_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } else { + payload.issues.push({ + input, + code: "too_small", + minimum: Number.MIN_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } + return; + } + } + if (input < minimum) { + payload.issues.push({ + origin: "number", + input, + code: "too_small", + minimum, + inclusive: true, + inst, + continue: !def.abort + }); + } + if (input > maximum) { + payload.issues.push({ + origin: "number", + input, + code: "too_big", + maximum, + inclusive: true, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat", (inst, def) => { + $ZodCheck.init(inst, def); + const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + bag.minimum = minimum; + bag.maximum = maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + if (input < minimum) { + payload.issues.push({ + origin: "bigint", + input, + code: "too_small", + minimum, + inclusive: true, + inst, + continue: !def.abort + }); + } + if (input > maximum) { + payload.issues.push({ + origin: "bigint", + input, + code: "too_big", + maximum, + inclusive: true, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => { + var _a2; + $ZodCheck.init(inst, def); + (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.size !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY; + if (def.maximum < curr) + inst2._zod.bag.maximum = def.maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const size = input.size; + if (size <= def.maximum) + return; + payload.issues.push({ + origin: getSizableOrigin(input), + code: "too_big", + maximum: def.maximum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => { + var _a2; + $ZodCheck.init(inst, def); + (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.size !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY; + if (def.minimum > curr) + inst2._zod.bag.minimum = def.minimum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const size = input.size; + if (size >= def.minimum) + return; + payload.issues.push({ + origin: getSizableOrigin(input), + code: "too_small", + minimum: def.minimum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => { + var _a2; + $ZodCheck.init(inst, def); + (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.size !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.minimum = def.size; + bag.maximum = def.size; + bag.size = def.size; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const size = input.size; + if (size === def.size) + return; + const tooBig = size > def.size; + payload.issues.push({ + origin: getSizableOrigin(input), + ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size }, + inclusive: true, + exact: true, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => { + var _a2; + $ZodCheck.init(inst, def); + (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY; + if (def.maximum < curr) + inst2._zod.bag.maximum = def.maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length <= def.maximum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_big", + maximum: def.maximum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => { + var _a2; + $ZodCheck.init(inst, def); + (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY; + if (def.minimum > curr) + inst2._zod.bag.minimum = def.minimum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length >= def.minimum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_small", + minimum: def.minimum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => { + var _a2; + $ZodCheck.init(inst, def); + (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.minimum = def.length; + bag.maximum = def.length; + bag.length = def.length; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length === def.length) + return; + const origin = getLengthableOrigin(input); + const tooBig = length > def.length; + payload.issues.push({ + origin, + ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }, + inclusive: true, + exact: true, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => { + var _a2, _b; + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + if (def.pattern) { + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(def.pattern); + } + }); + if (def.pattern) + (_a2 = inst._zod).check ?? (_a2.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: def.format, + input: payload.value, + ...def.pattern ? { pattern: def.pattern.toString() } : {}, + inst, + continue: !def.abort + }); + }); + else + (_b = inst._zod).check ?? (_b.check = () => { + }); +}); +var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + inst._zod.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "regex", + input: payload.value, + pattern: def.pattern.toString(), + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => { + def.pattern ?? (def.pattern = lowercase); + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => { + def.pattern ?? (def.pattern = uppercase); + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => { + $ZodCheck.init(inst, def); + const escapedRegex = escapeRegex(def.includes); + const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex); + def.pattern = pattern; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.includes(def.includes, def.position)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "includes", + includes: def.includes, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.startsWith(def.prefix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "starts_with", + prefix: def.prefix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.endsWith(def.suffix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "ends_with", + suffix: def.suffix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +function handleCheckPropertyResult(result, payload, property) { + if (result.issues.length) { + payload.issues.push(...prefixIssues(property, result.issues)); + } +} +var $ZodCheckProperty = /* @__PURE__ */ $constructor("$ZodCheckProperty", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.check = (payload) => { + const result = def.schema._zod.run({ + value: payload.value[def.property], + issues: [] + }, {}); + if (result instanceof Promise) { + return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property)); + } + handleCheckPropertyResult(result, payload, def.property); + return; + }; +}); +var $ZodCheckMimeType = /* @__PURE__ */ $constructor("$ZodCheckMimeType", (inst, def) => { + $ZodCheck.init(inst, def); + const mimeSet = new Set(def.mime); + inst._zod.onattach.push((inst2) => { + inst2._zod.bag.mime = def.mime; + }); + inst._zod.check = (payload) => { + if (mimeSet.has(payload.value.type)) + return; + payload.issues.push({ + code: "invalid_value", + values: def.mime, + input: payload.value.type, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.check = (payload) => { + payload.value = def.tx(payload.value); + }; +}); + +// node_modules/zod/v4/core/doc.js +var Doc = class { + constructor(args = []) { + this.content = []; + this.indent = 0; + if (this) + this.args = args; + } + indented(fn) { + this.indent += 1; + fn(this); + this.indent -= 1; + } + write(arg) { + if (typeof arg === "function") { + arg(this, { execution: "sync" }); + arg(this, { execution: "async" }); + return; + } + const content = arg; + const lines = content.split("\n").filter((x) => x); + const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length)); + const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x); + for (const line of dedented) { + this.content.push(line); + } + } + compile() { + const F = Function; + const args = this?.args; + const content = this?.content ?? [``]; + const lines = [...content.map((x) => ` ${x}`)]; + return new F(...args, lines.join("\n")); + } +}; + +// node_modules/zod/v4/core/versions.js +var version = { + major: 4, + minor: 3, + patch: 6 +}; + +// node_modules/zod/v4/core/schemas.js +var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => { + var _a2; + inst ?? (inst = {}); + inst._zod.def = def; + inst._zod.bag = inst._zod.bag || {}; + inst._zod.version = version; + const checks = [...inst._zod.def.checks ?? []]; + if (inst._zod.traits.has("$ZodCheck")) { + checks.unshift(inst); + } + for (const ch of checks) { + for (const fn of ch._zod.onattach) { + fn(inst); + } + } + if (checks.length === 0) { + (_a2 = inst._zod).deferred ?? (_a2.deferred = []); + inst._zod.deferred?.push(() => { + inst._zod.run = inst._zod.parse; + }); + } else { + const runChecks = (payload, checks2, ctx) => { + let isAborted2 = aborted(payload); + let asyncResult; + for (const ch of checks2) { + if (ch._zod.def.when) { + const shouldRun = ch._zod.def.when(payload); + if (!shouldRun) + continue; + } else if (isAborted2) { + continue; + } + const currLen = payload.issues.length; + const _ = ch._zod.check(payload); + if (_ instanceof Promise && ctx?.async === false) { + throw new $ZodAsyncError(); + } + if (asyncResult || _ instanceof Promise) { + asyncResult = (asyncResult ?? Promise.resolve()).then(async () => { + await _; + const nextLen = payload.issues.length; + if (nextLen === currLen) + return; + if (!isAborted2) + isAborted2 = aborted(payload, currLen); + }); + } else { + const nextLen = payload.issues.length; + if (nextLen === currLen) + continue; + if (!isAborted2) + isAborted2 = aborted(payload, currLen); + } + } + if (asyncResult) { + return asyncResult.then(() => { + return payload; + }); + } + return payload; + }; + const handleCanaryResult = (canary, payload, ctx) => { + if (aborted(canary)) { + canary.aborted = true; + return canary; + } + const checkResult = runChecks(payload, checks, ctx); + if (checkResult instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx)); + } + return inst._zod.parse(checkResult, ctx); + }; + inst._zod.run = (payload, ctx) => { + if (ctx.skipChecks) { + return inst._zod.parse(payload, ctx); + } + if (ctx.direction === "backward") { + const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true }); + if (canary instanceof Promise) { + return canary.then((canary2) => { + return handleCanaryResult(canary2, payload, ctx); + }); + } + return handleCanaryResult(canary, payload, ctx); + } + const result = inst._zod.parse(payload, ctx); + if (result instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return result.then((result2) => runChecks(result2, checks, ctx)); + } + return runChecks(result, checks, ctx); + }; + } + defineLazy(inst, "~standard", () => ({ + validate: (value) => { + try { + const r = safeParse(inst, value); + return r.success ? { value: r.data } : { issues: r.error?.issues }; + } catch (_) { + return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues }); + } + }, + vendor: "zod", + version: 1 + })); +}); +var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag); + inst._zod.parse = (payload, _) => { + if (def.coerce) + try { + payload.value = String(payload.value); + } catch (_2) { + } + if (typeof payload.value === "string") + return payload; + payload.issues.push({ + expected: "string", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + $ZodString.init(inst, def); +}); +var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => { + def.pattern ?? (def.pattern = guid); + $ZodStringFormat.init(inst, def); +}); +var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => { + if (def.version) { + const versionMap = { + v1: 1, + v2: 2, + v3: 3, + v4: 4, + v5: 5, + v6: 6, + v7: 7, + v8: 8 + }; + const v = versionMap[def.version]; + if (v === void 0) + throw new Error(`Invalid UUID version: "${def.version}"`); + def.pattern ?? (def.pattern = uuid(v)); + } else + def.pattern ?? (def.pattern = uuid()); + $ZodStringFormat.init(inst, def); +}); +var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => { + def.pattern ?? (def.pattern = email); + $ZodStringFormat.init(inst, def); +}); +var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + try { + const trimmed = payload.value.trim(); + const url2 = new URL(trimmed); + if (def.hostname) { + def.hostname.lastIndex = 0; + if (!def.hostname.test(url2.hostname)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid hostname", + pattern: def.hostname.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.protocol) { + def.protocol.lastIndex = 0; + if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid protocol", + pattern: def.protocol.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.normalize) { + payload.value = url2.href; + } else { + payload.value = trimmed; + } + return; + } catch (_) { + payload.issues.push({ + code: "invalid_format", + format: "url", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => { + def.pattern ?? (def.pattern = emoji()); + $ZodStringFormat.init(inst, def); +}); +var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => { + def.pattern ?? (def.pattern = nanoid); + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => { + def.pattern ?? (def.pattern = cuid); + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => { + def.pattern ?? (def.pattern = cuid2); + $ZodStringFormat.init(inst, def); +}); +var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => { + def.pattern ?? (def.pattern = ulid); + $ZodStringFormat.init(inst, def); +}); +var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => { + def.pattern ?? (def.pattern = xid); + $ZodStringFormat.init(inst, def); +}); +var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => { + def.pattern ?? (def.pattern = ksuid); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => { + def.pattern ?? (def.pattern = datetime(def)); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => { + def.pattern ?? (def.pattern = date); + $ZodStringFormat.init(inst, def); +}); +var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => { + def.pattern ?? (def.pattern = time(def)); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => { + def.pattern ?? (def.pattern = duration); + $ZodStringFormat.init(inst, def); +}); +var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => { + def.pattern ?? (def.pattern = ipv4); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv4`; +}); +var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => { + def.pattern ?? (def.pattern = ipv6); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv6`; + inst._zod.check = (payload) => { + try { + new URL(`http://[${payload.value}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "ipv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodMAC = /* @__PURE__ */ $constructor("$ZodMAC", (inst, def) => { + def.pattern ?? (def.pattern = mac(def.delimiter)); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `mac`; +}); +var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => { + def.pattern ?? (def.pattern = cidrv4); + $ZodStringFormat.init(inst, def); +}); +var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => { + def.pattern ?? (def.pattern = cidrv6); + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + const parts = payload.value.split("/"); + try { + if (parts.length !== 2) + throw new Error(); + const [address, prefix] = parts; + if (!prefix) + throw new Error(); + const prefixNum = Number(prefix); + if (`${prefixNum}` !== prefix) + throw new Error(); + if (prefixNum < 0 || prefixNum > 128) + throw new Error(); + new URL(`http://[${address}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "cidrv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +function isValidBase64(data) { + if (data === "") + return true; + if (data.length % 4 !== 0) + return false; + try { + atob(data); + return true; + } catch { + return false; + } +} +var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => { + def.pattern ?? (def.pattern = base64); + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64"; + inst._zod.check = (payload) => { + if (isValidBase64(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +function isValidBase64URL(data) { + if (!base64url.test(data)) + return false; + const base643 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/"); + const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, "="); + return isValidBase64(padded); +} +var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => { + def.pattern ?? (def.pattern = base64url); + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64url"; + inst._zod.check = (payload) => { + if (isValidBase64URL(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64url", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => { + def.pattern ?? (def.pattern = e164); + $ZodStringFormat.init(inst, def); +}); +function isValidJWT2(token, algorithm = null) { + try { + const tokensParts = token.split("."); + if (tokensParts.length !== 3) + return false; + const [header] = tokensParts; + if (!header) + return false; + const parsedHeader = JSON.parse(atob(header)); + if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") + return false; + if (!parsedHeader.alg) + return false; + if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) + return false; + return true; + } catch { + return false; + } +} +var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + if (isValidJWT2(payload.value, def.alg)) + return; + payload.issues.push({ + code: "invalid_format", + format: "jwt", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + if (def.fn(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: def.format, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = inst._zod.bag.pattern ?? number; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = Number(payload.value); + } catch (_) { + } + const input = payload.value; + if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) { + return payload; + } + const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0; + payload.issues.push({ + expected: "number", + code: "invalid_type", + input, + inst, + ...received ? { received } : {} + }); + return payload; + }; +}); +var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => { + $ZodCheckNumberFormat.init(inst, def); + $ZodNumber.init(inst, def); +}); +var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = boolean; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = Boolean(payload.value); + } catch (_) { + } + const input = payload.value; + if (typeof input === "boolean") + return payload; + payload.issues.push({ + expected: "boolean", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = bigint; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = BigInt(payload.value); + } catch (_) { + } + if (typeof payload.value === "bigint") + return payload; + payload.issues.push({ + expected: "bigint", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigIntFormat", (inst, def) => { + $ZodCheckBigIntFormat.init(inst, def); + $ZodBigInt.init(inst, def); +}); +var $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (typeof input === "symbol") + return payload; + payload.issues.push({ + expected: "symbol", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = _undefined; + inst._zod.values = /* @__PURE__ */ new Set([void 0]); + inst._zod.optin = "optional"; + inst._zod.optout = "optional"; + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (typeof input === "undefined") + return payload; + payload.issues.push({ + expected: "undefined", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = _null; + inst._zod.values = /* @__PURE__ */ new Set([null]); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (input === null) + return payload; + payload.issues.push({ + expected: "null", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + payload.issues.push({ + expected: "never", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (typeof input === "undefined") + return payload; + payload.issues.push({ + expected: "void", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) { + try { + payload.value = new Date(payload.value); + } catch (_err) { + } + } + const input = payload.value; + const isDate = input instanceof Date; + const isValidDate = isDate && !Number.isNaN(input.getTime()); + if (isValidDate) + return payload; + payload.issues.push({ + expected: "date", + code: "invalid_type", + input, + ...isDate ? { received: "Invalid Date" } : {}, + inst + }); + return payload; + }; +}); +function handleArrayResult(result, final, index) { + if (result.issues.length) { + final.issues.push(...prefixIssues(index, result.issues)); + } + final.value[index] = result.value; +} +var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!Array.isArray(input)) { + payload.issues.push({ + expected: "array", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = Array(input.length); + const proms = []; + for (let i = 0; i < input.length; i++) { + const item = input[i]; + const result = def.element._zod.run({ + value: item, + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleArrayResult(result2, payload, i))); + } else { + handleArrayResult(result, payload, i); + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +function handlePropertyResult(result, final, key, input, isOptionalOut) { + if (result.issues.length) { + if (isOptionalOut && !(key in input)) { + return; + } + final.issues.push(...prefixIssues(key, result.issues)); + } + if (result.value === void 0) { + if (key in input) { + final.value[key] = void 0; + } + } else { + final.value[key] = result.value; + } +} +function normalizeDef(def) { + const keys = Object.keys(def.shape); + for (const k of keys) { + if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) { + throw new Error(`Invalid element at key "${k}": expected a Zod schema`); + } + } + const okeys = optionalKeys(def.shape); + return { + ...def, + keys, + keySet: new Set(keys), + numKeys: keys.length, + optionalKeys: new Set(okeys) + }; +} +function handleCatchall(proms, input, payload, ctx, def, inst) { + const unrecognized = []; + const keySet = def.keySet; + const _catchall = def.catchall._zod; + const t = _catchall.def.type; + const isOptionalOut = _catchall.optout === "optional"; + for (const key in input) { + if (keySet.has(key)) + continue; + if (t === "never") { + unrecognized.push(key); + continue; + } + const r = _catchall.run({ value: input[key], issues: [] }, ctx); + if (r instanceof Promise) { + proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut))); + } else { + handlePropertyResult(r, payload, key, input, isOptionalOut); + } + } + if (unrecognized.length) { + payload.issues.push({ + code: "unrecognized_keys", + keys: unrecognized, + input, + inst + }); + } + if (!proms.length) + return payload; + return Promise.all(proms).then(() => { + return payload; + }); +} +var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => { + $ZodType.init(inst, def); + const desc = Object.getOwnPropertyDescriptor(def, "shape"); + if (!desc?.get) { + const sh = def.shape; + Object.defineProperty(def, "shape", { + get: () => { + const newSh = { ...sh }; + Object.defineProperty(def, "shape", { + value: newSh + }); + return newSh; + } + }); + } + const _normalized = cached(() => normalizeDef(def)); + defineLazy(inst._zod, "propValues", () => { + const shape = def.shape; + const propValues = {}; + for (const key in shape) { + const field = shape[key]._zod; + if (field.values) { + propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set()); + for (const v of field.values) + propValues[key].add(v); + } + } + return propValues; + }); + const isObject2 = isObject; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value ?? (value = _normalized.value); + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = {}; + const proms = []; + const shape = value.shape; + for (const key of value.keys) { + const el = shape[key]; + const isOptionalOut = el._zod.optout === "optional"; + const r = el._zod.run({ value: input[key], issues: [] }, ctx); + if (r instanceof Promise) { + proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut))); + } else { + handlePropertyResult(r, payload, key, input, isOptionalOut); + } + } + if (!catchall) { + return proms.length ? Promise.all(proms).then(() => payload) : payload; + } + return handleCatchall(proms, input, payload, ctx, _normalized.value, inst); + }; +}); +var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => { + $ZodObject.init(inst, def); + const superParse = inst._zod.parse; + const _normalized = cached(() => normalizeDef(def)); + const generateFastpass = (shape) => { + const doc = new Doc(["shape", "payload", "ctx"]); + const normalized = _normalized.value; + const parseStr = (key) => { + const k = esc(key); + return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`; + }; + doc.write(`const input = payload.value;`); + const ids = /* @__PURE__ */ Object.create(null); + let counter = 0; + for (const key of normalized.keys) { + ids[key] = `key_${counter++}`; + } + doc.write(`const newResult = {};`); + for (const key of normalized.keys) { + const id = ids[key]; + const k = esc(key); + const schema = shape[key]; + const isOptionalOut = schema?._zod?.optout === "optional"; + doc.write(`const ${id} = ${parseStr(key)};`); + if (isOptionalOut) { + doc.write(` + if (${id}.issues.length) { + if (${k} in input) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + } + + if (${id}.value === undefined) { + if (${k} in input) { + newResult[${k}] = undefined; + } + } else { + newResult[${k}] = ${id}.value; + } + + `); + } else { + doc.write(` + if (${id}.issues.length) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + + if (${id}.value === undefined) { + if (${k} in input) { + newResult[${k}] = undefined; + } + } else { + newResult[${k}] = ${id}.value; + } + + `); + } + } + doc.write(`payload.value = newResult;`); + doc.write(`return payload;`); + const fn = doc.compile(); + return (payload, ctx) => fn(shape, payload, ctx); + }; + let fastpass; + const isObject2 = isObject; + const jit = !globalConfig.jitless; + const allowsEval2 = allowsEval; + const fastEnabled = jit && allowsEval2.value; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value ?? (value = _normalized.value); + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) { + if (!fastpass) + fastpass = generateFastpass(def.shape); + payload = fastpass(payload, ctx); + if (!catchall) + return payload; + return handleCatchall([], input, payload, ctx, value, inst); + } + return superParse(payload, ctx); + }; +}); +function handleUnionResults(results, final, inst, ctx) { + for (const result of results) { + if (result.issues.length === 0) { + final.value = result.value; + return final; + } + } + const nonaborted = results.filter((r) => !aborted(r)); + if (nonaborted.length === 1) { + final.value = nonaborted[0].value; + return nonaborted[0]; + } + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + }); + return final; +} +var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "values", () => { + if (def.options.every((o) => o._zod.values)) { + return new Set(def.options.flatMap((option) => Array.from(option._zod.values))); + } + return void 0; + }); + defineLazy(inst._zod, "pattern", () => { + if (def.options.every((o) => o._zod.pattern)) { + const patterns = def.options.map((o) => o._zod.pattern); + return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`); + } + return void 0; + }); + const single = def.options.length === 1; + const first = def.options[0]._zod.run; + inst._zod.parse = (payload, ctx) => { + if (single) { + return first(payload, ctx); + } + let async = false; + const results = []; + for (const option of def.options) { + const result = option._zod.run({ + value: payload.value, + issues: [] + }, ctx); + if (result instanceof Promise) { + results.push(result); + async = true; + } else { + if (result.issues.length === 0) + return result; + results.push(result); + } + } + if (!async) + return handleUnionResults(results, payload, inst, ctx); + return Promise.all(results).then((results2) => { + return handleUnionResults(results2, payload, inst, ctx); + }); + }; +}); +function handleExclusiveUnionResults(results, final, inst, ctx) { + const successes = results.filter((r) => r.issues.length === 0); + if (successes.length === 1) { + final.value = successes[0].value; + return final; + } + if (successes.length === 0) { + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + }); + } else { + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: [], + inclusive: false + }); + } + return final; +} +var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => { + $ZodUnion.init(inst, def); + def.inclusive = false; + const single = def.options.length === 1; + const first = def.options[0]._zod.run; + inst._zod.parse = (payload, ctx) => { + if (single) { + return first(payload, ctx); + } + let async = false; + const results = []; + for (const option of def.options) { + const result = option._zod.run({ + value: payload.value, + issues: [] + }, ctx); + if (result instanceof Promise) { + results.push(result); + async = true; + } else { + results.push(result); + } + } + if (!async) + return handleExclusiveUnionResults(results, payload, inst, ctx); + return Promise.all(results).then((results2) => { + return handleExclusiveUnionResults(results2, payload, inst, ctx); + }); + }; +}); +var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => { + def.inclusive = false; + $ZodUnion.init(inst, def); + const _super = inst._zod.parse; + defineLazy(inst._zod, "propValues", () => { + const propValues = {}; + for (const option of def.options) { + const pv = option._zod.propValues; + if (!pv || Object.keys(pv).length === 0) + throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`); + for (const [k, v] of Object.entries(pv)) { + if (!propValues[k]) + propValues[k] = /* @__PURE__ */ new Set(); + for (const val of v) { + propValues[k].add(val); + } + } + } + return propValues; + }); + const disc = cached(() => { + const opts = def.options; + const map2 = /* @__PURE__ */ new Map(); + for (const o of opts) { + const values = o._zod.propValues?.[def.discriminator]; + if (!values || values.size === 0) + throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`); + for (const v of values) { + if (map2.has(v)) { + throw new Error(`Duplicate discriminator value "${String(v)}"`); + } + map2.set(v, o); + } + } + return map2; + }); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!isObject(input)) { + payload.issues.push({ + code: "invalid_type", + expected: "object", + input, + inst + }); + return payload; + } + const opt = disc.value.get(input?.[def.discriminator]); + if (opt) { + return opt._zod.run(payload, ctx); + } + if (def.unionFallback) { + return _super(payload, ctx); + } + payload.issues.push({ + code: "invalid_union", + errors: [], + note: "No matching discriminator", + discriminator: def.discriminator, + input, + path: [def.discriminator], + inst + }); + return payload; + }; +}); +var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + const left = def.left._zod.run({ value: input, issues: [] }, ctx); + const right = def.right._zod.run({ value: input, issues: [] }, ctx); + const async = left instanceof Promise || right instanceof Promise; + if (async) { + return Promise.all([left, right]).then(([left2, right2]) => { + return handleIntersectionResults(payload, left2, right2); + }); + } + return handleIntersectionResults(payload, left, right); + }; +}); +function mergeValues2(a, b) { + if (a === b) { + return { valid: true, data: a }; + } + if (a instanceof Date && b instanceof Date && +a === +b) { + return { valid: true, data: a }; + } + if (isPlainObject(a) && isPlainObject(b)) { + const bKeys = Object.keys(b); + const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues2(a[key], b[key]); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [key, ...sharedValue.mergeErrorPath] + }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } + if (Array.isArray(a) && Array.isArray(b)) { + if (a.length !== b.length) { + return { valid: false, mergeErrorPath: [] }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues2(itemA, itemB); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [index, ...sharedValue.mergeErrorPath] + }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } + return { valid: false, mergeErrorPath: [] }; +} +function handleIntersectionResults(result, left, right) { + const unrecKeys = /* @__PURE__ */ new Map(); + let unrecIssue; + for (const iss of left.issues) { + if (iss.code === "unrecognized_keys") { + unrecIssue ?? (unrecIssue = iss); + for (const k of iss.keys) { + if (!unrecKeys.has(k)) + unrecKeys.set(k, {}); + unrecKeys.get(k).l = true; + } + } else { + result.issues.push(iss); + } + } + for (const iss of right.issues) { + if (iss.code === "unrecognized_keys") { + for (const k of iss.keys) { + if (!unrecKeys.has(k)) + unrecKeys.set(k, {}); + unrecKeys.get(k).r = true; + } + } else { + result.issues.push(iss); + } + } + const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k); + if (bothKeys.length && unrecIssue) { + result.issues.push({ ...unrecIssue, keys: bothKeys }); + } + if (aborted(result)) + return result; + const merged = mergeValues2(left.value, right.value); + if (!merged.valid) { + throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`); + } + result.value = merged.data; + return result; +} +var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => { + $ZodType.init(inst, def); + const items = def.items; + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!Array.isArray(input)) { + payload.issues.push({ + input, + inst, + expected: "tuple", + code: "invalid_type" + }); + return payload; + } + payload.value = []; + const proms = []; + const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional"); + const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex; + if (!def.rest) { + const tooBig = input.length > items.length; + const tooSmall = input.length < optStart - 1; + if (tooBig || tooSmall) { + payload.issues.push({ + ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length }, + input, + inst, + origin: "array" + }); + return payload; + } + } + let i = -1; + for (const item of items) { + i++; + if (i >= input.length) { + if (i >= optStart) + continue; + } + const result = item._zod.run({ + value: input[i], + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleTupleResult(result2, payload, i))); + } else { + handleTupleResult(result, payload, i); + } + } + if (def.rest) { + const rest = input.slice(items.length); + for (const el of rest) { + i++; + const result = def.rest._zod.run({ + value: el, + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleTupleResult(result2, payload, i))); + } else { + handleTupleResult(result, payload, i); + } + } + } + if (proms.length) + return Promise.all(proms).then(() => payload); + return payload; + }; +}); +function handleTupleResult(result, final, index) { + if (result.issues.length) { + final.issues.push(...prefixIssues(index, result.issues)); + } + final.value[index] = result.value; +} +var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!isPlainObject(input)) { + payload.issues.push({ + expected: "record", + code: "invalid_type", + input, + inst + }); + return payload; + } + const proms = []; + const values = def.keyType._zod.values; + if (values) { + payload.value = {}; + const recordKeys = /* @__PURE__ */ new Set(); + for (const key of values) { + if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") { + recordKeys.add(typeof key === "number" ? key.toString() : key); + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[key] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[key] = result.value; + } + } + } + let unrecognized; + for (const key in input) { + if (!recordKeys.has(key)) { + unrecognized = unrecognized ?? []; + unrecognized.push(key); + } + } + if (unrecognized && unrecognized.length > 0) { + payload.issues.push({ + code: "unrecognized_keys", + input, + inst, + keys: unrecognized + }); + } + } else { + payload.value = {}; + for (const key of Reflect.ownKeys(input)) { + if (key === "__proto__") + continue; + let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + if (keyResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length; + if (checkNumericKey) { + const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx); + if (retryResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + if (retryResult.issues.length === 0) { + keyResult = retryResult; + } + } + if (keyResult.issues.length) { + if (def.mode === "loose") { + payload.value[key] = input[key]; + } else { + payload.issues.push({ + code: "invalid_key", + origin: "record", + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())), + input: key, + path: [key], + inst + }); + } + continue; + } + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[keyResult.value] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[keyResult.value] = result.value; + } + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!(input instanceof Map)) { + payload.issues.push({ + expected: "map", + code: "invalid_type", + input, + inst + }); + return payload; + } + const proms = []; + payload.value = /* @__PURE__ */ new Map(); + for (const [key, value] of input) { + const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx); + if (keyResult instanceof Promise || valueResult instanceof Promise) { + proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => { + handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx); + })); + } else { + handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx); + } + } + if (proms.length) + return Promise.all(proms).then(() => payload); + return payload; + }; +}); +function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) { + if (keyResult.issues.length) { + if (propertyKeyTypes.has(typeof key)) { + final.issues.push(...prefixIssues(key, keyResult.issues)); + } else { + final.issues.push({ + code: "invalid_key", + origin: "map", + input, + inst, + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }); + } + } + if (valueResult.issues.length) { + if (propertyKeyTypes.has(typeof key)) { + final.issues.push(...prefixIssues(key, valueResult.issues)); + } else { + final.issues.push({ + origin: "map", + code: "invalid_element", + input, + inst, + key, + issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }); + } + } + final.value.set(keyResult.value, valueResult.value); +} +var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!(input instanceof Set)) { + payload.issues.push({ + input, + inst, + expected: "set", + code: "invalid_type" + }); + return payload; + } + const proms = []; + payload.value = /* @__PURE__ */ new Set(); + for (const item of input) { + const result = def.valueType._zod.run({ value: item, issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleSetResult(result2, payload))); + } else + handleSetResult(result, payload); + } + if (proms.length) + return Promise.all(proms).then(() => payload); + return payload; + }; +}); +function handleSetResult(result, final) { + if (result.issues.length) { + final.issues.push(...result.issues); + } + final.value.add(result.value); +} +var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => { + $ZodType.init(inst, def); + const values = getEnumValues(def.entries); + const valuesSet = new Set(values); + inst._zod.values = valuesSet; + inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (valuesSet.has(input)) { + return payload; + } + payload.issues.push({ + code: "invalid_value", + values, + input, + inst + }); + return payload; + }; +}); +var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => { + $ZodType.init(inst, def); + if (def.values.length === 0) { + throw new Error("Cannot create literal schema with no valid values"); + } + const values = new Set(def.values); + inst._zod.values = values; + inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (values.has(input)) { + return payload; + } + payload.issues.push({ + code: "invalid_value", + values: def.values, + input, + inst + }); + return payload; + }; +}); +var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (input instanceof File) + return payload; + payload.issues.push({ + expected: "file", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + const _out = def.transform(payload.value, payload); + if (ctx.async) { + const output = _out instanceof Promise ? _out : Promise.resolve(_out); + return output.then((output2) => { + payload.value = output2; + return payload; + }); + } + if (_out instanceof Promise) { + throw new $ZodAsyncError(); + } + payload.value = _out; + return payload; + }; +}); +function handleOptionalResult(result, input) { + if (result.issues.length && input === void 0) { + return { issues: [], value: void 0 }; + } + return result; +} +var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + inst._zod.optout = "optional"; + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0; + }); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (def.innerType._zod.optin === "optional") { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) + return result.then((r) => handleOptionalResult(r, payload.value)); + return handleOptionalResult(result, payload.value); + } + if (payload.value === void 0) { + return payload; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => { + $ZodOptional.init(inst, def); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern); + inst._zod.parse = (payload, ctx) => { + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0; + }); + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (payload.value === null) + return payload; + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + return payload; + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleDefaultResult(result2, def)); + } + return handleDefaultResult(result, def); + }; +}); +function handleDefaultResult(payload, def) { + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return payload; +} +var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => { + const v = def.innerType._zod.values; + return v ? new Set([...v].filter((x) => x !== void 0)) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleNonOptionalResult(result2, inst)); + } + return handleNonOptionalResult(result, inst); + }; +}); +function handleNonOptionalResult(payload, inst) { + if (!payload.issues.length && payload.value === void 0) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: payload.value, + inst + }); + } + return payload; +} +var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + throw new $ZodEncodeError("ZodSuccess"); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => { + payload.value = result2.issues.length === 0; + return payload; + }); + } + payload.value = result.issues.length === 0; + return payload; + }; +}); +var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => { + payload.value = result2.value; + if (result2.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + } + return payload; + }); + } + payload.value = result.value; + if (result.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + } + return payload; + }; +}); +var $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) { + payload.issues.push({ + input: payload.value, + inst, + expected: "nan", + code: "invalid_type" + }); + return payload; + } + return payload; + }; +}); +var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => def.in._zod.values); + defineLazy(inst._zod, "optin", () => def.in._zod.optin); + defineLazy(inst._zod, "optout", () => def.out._zod.optout); + defineLazy(inst._zod, "propValues", () => def.in._zod.propValues); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + const right = def.out._zod.run(payload, ctx); + if (right instanceof Promise) { + return right.then((right2) => handlePipeResult(right2, def.in, ctx)); + } + return handlePipeResult(right, def.in, ctx); + } + const left = def.in._zod.run(payload, ctx); + if (left instanceof Promise) { + return left.then((left2) => handlePipeResult(left2, def.out, ctx)); + } + return handlePipeResult(left, def.out, ctx); + }; +}); +function handlePipeResult(left, next, ctx) { + if (left.issues.length) { + left.aborted = true; + return left; + } + return next._zod.run({ value: left.value, issues: left.issues }, ctx); +} +var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => def.in._zod.values); + defineLazy(inst._zod, "optin", () => def.in._zod.optin); + defineLazy(inst._zod, "optout", () => def.out._zod.optout); + defineLazy(inst._zod, "propValues", () => def.in._zod.propValues); + inst._zod.parse = (payload, ctx) => { + const direction = ctx.direction || "forward"; + if (direction === "forward") { + const left = def.in._zod.run(payload, ctx); + if (left instanceof Promise) { + return left.then((left2) => handleCodecAResult(left2, def, ctx)); + } + return handleCodecAResult(left, def, ctx); + } else { + const right = def.out._zod.run(payload, ctx); + if (right instanceof Promise) { + return right.then((right2) => handleCodecAResult(right2, def, ctx)); + } + return handleCodecAResult(right, def, ctx); + } + }; +}); +function handleCodecAResult(result, def, ctx) { + if (result.issues.length) { + result.aborted = true; + return result; + } + const direction = ctx.direction || "forward"; + if (direction === "forward") { + const transformed = def.transform(result.value, result); + if (transformed instanceof Promise) { + return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx)); + } + return handleCodecTxResult(result, transformed, def.out, ctx); + } else { + const transformed = def.reverseTransform(result.value, result); + if (transformed instanceof Promise) { + return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx)); + } + return handleCodecTxResult(result, transformed, def.in, ctx); + } +} +function handleCodecTxResult(left, value, nextSchema, ctx) { + if (left.issues.length) { + left.aborted = true; + return left; + } + return nextSchema._zod.run({ value, issues: left.issues }, ctx); +} +var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin); + defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then(handleReadonlyResult); + } + return handleReadonlyResult(result); + }; +}); +function handleReadonlyResult(payload) { + payload.value = Object.freeze(payload.value); + return payload; +} +var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => { + $ZodType.init(inst, def); + const regexParts = []; + for (const part of def.parts) { + if (typeof part === "object" && part !== null) { + if (!part._zod.pattern) { + throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`); + } + const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern; + if (!source) + throw new Error(`Invalid template literal part: ${part._zod.traits}`); + const start = source.startsWith("^") ? 1 : 0; + const end = source.endsWith("$") ? source.length - 1 : source.length; + regexParts.push(source.slice(start, end)); + } else if (part === null || primitiveTypes.has(typeof part)) { + regexParts.push(escapeRegex(`${part}`)); + } else { + throw new Error(`Invalid template literal part: ${part}`); + } + } + inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`); + inst._zod.parse = (payload, _ctx) => { + if (typeof payload.value !== "string") { + payload.issues.push({ + input: payload.value, + inst, + expected: "string", + code: "invalid_type" + }); + return payload; + } + inst._zod.pattern.lastIndex = 0; + if (!inst._zod.pattern.test(payload.value)) { + payload.issues.push({ + input: payload.value, + inst, + code: "invalid_format", + format: def.format ?? "template_literal", + pattern: inst._zod.pattern.source + }); + return payload; + } + return payload; + }; +}); +var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => { + $ZodType.init(inst, def); + inst._def = def; + inst._zod.def = def; + inst.implement = (func) => { + if (typeof func !== "function") { + throw new Error("implement() must be called with a function"); + } + return function(...args) { + const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args; + const result = Reflect.apply(func, this, parsedArgs); + if (inst._def.output) { + return parse(inst._def.output, result); + } + return result; + }; + }; + inst.implementAsync = (func) => { + if (typeof func !== "function") { + throw new Error("implementAsync() must be called with a function"); + } + return async function(...args) { + const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args; + const result = await Reflect.apply(func, this, parsedArgs); + if (inst._def.output) { + return await parseAsync(inst._def.output, result); + } + return result; + }; + }; + inst._zod.parse = (payload, _ctx) => { + if (typeof payload.value !== "function") { + payload.issues.push({ + code: "invalid_type", + expected: "function", + input: payload.value, + inst + }); + return payload; + } + const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise"; + if (hasPromiseOutput) { + payload.value = inst.implementAsync(payload.value); + } else { + payload.value = inst.implement(payload.value); + } + return payload; + }; + inst.input = (...args) => { + const F = inst.constructor; + if (Array.isArray(args[0])) { + return new F({ + type: "function", + input: new $ZodTuple({ + type: "tuple", + items: args[0], + rest: args[1] + }), + output: inst._def.output + }); + } + return new F({ + type: "function", + input: args[0], + output: inst._def.output + }); + }; + inst.output = (output) => { + const F = inst.constructor; + return new F({ + type: "function", + input: inst._def.input, + output + }); + }; + return inst; +}); +var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx)); + }; +}); +var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "innerType", () => def.getter()); + defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern); + defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues); + defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0); + defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0); + inst._zod.parse = (payload, ctx) => { + const inner = inst._zod.innerType; + return inner._zod.run(payload, ctx); + }; +}); +var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => { + $ZodCheck.init(inst, def); + $ZodType.init(inst, def); + inst._zod.parse = (payload, _) => { + return payload; + }; + inst._zod.check = (payload) => { + const input = payload.value; + const r = def.fn(input); + if (r instanceof Promise) { + return r.then((r2) => handleRefineResult(r2, payload, input, inst)); + } + handleRefineResult(r, payload, input, inst); + return; + }; +}); +function handleRefineResult(result, payload, input, inst) { + if (!result) { + const _iss = { + code: "custom", + input, + inst, + // incorporates params.error into issue reporting + path: [...inst._zod.def.path ?? []], + // incorporates params.error into issue reporting + continue: !inst._zod.def.abort + // params: inst._zod.def.params, + }; + if (inst._zod.def.params) + _iss.params = inst._zod.def.params; + payload.issues.push(issue(_iss)); + } +} + +// node_modules/zod/v4/locales/en.js +var error = () => { + const Sizable = { + string: { unit: "characters", verb: "to have" }, + file: { unit: "bytes", verb: "to have" }, + array: { unit: "items", verb: "to have" }, + set: { unit: "items", verb: "to have" }, + map: { unit: "entries", verb: "to have" } + }; + function getSizing(origin) { + return Sizable[origin] ?? null; + } + const FormatDictionary = { + regex: "input", + email: "email address", + url: "URL", + emoji: "emoji", + uuid: "UUID", + uuidv4: "UUIDv4", + uuidv6: "UUIDv6", + nanoid: "nanoid", + guid: "GUID", + cuid: "cuid", + cuid2: "cuid2", + ulid: "ULID", + xid: "XID", + ksuid: "KSUID", + datetime: "ISO datetime", + date: "ISO date", + time: "ISO time", + duration: "ISO duration", + ipv4: "IPv4 address", + ipv6: "IPv6 address", + mac: "MAC address", + cidrv4: "IPv4 range", + cidrv6: "IPv6 range", + base64: "base64-encoded string", + base64url: "base64url-encoded string", + json_string: "JSON string", + e164: "E.164 number", + jwt: "JWT", + template_literal: "input" + }; + const TypeDictionary = { + // Compatibility: "nan" -> "NaN" for display + nan: "NaN" + // All other type names omitted - they fall back to raw values via ?? operator + }; + return (issue2) => { + switch (issue2.code) { + case "invalid_type": { + const expected = TypeDictionary[issue2.expected] ?? issue2.expected; + const receivedType = parsedType(issue2.input); + const received = TypeDictionary[receivedType] ?? receivedType; + return `Invalid input: expected ${expected}, received ${received}`; + } + case "invalid_value": + if (issue2.values.length === 1) + return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`; + return `Invalid option: expected one of ${joinValues(issue2.values, "|")}`; + case "too_big": { + const adj = issue2.inclusive ? "<=" : "<"; + const sizing = getSizing(issue2.origin); + if (sizing) + return `Too big: expected ${issue2.origin ?? "value"} to have ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`; + return `Too big: expected ${issue2.origin ?? "value"} to be ${adj}${issue2.maximum.toString()}`; + } + case "too_small": { + const adj = issue2.inclusive ? ">=" : ">"; + const sizing = getSizing(issue2.origin); + if (sizing) { + return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`; + } + return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`; + } + case "invalid_format": { + const _issue = issue2; + if (_issue.format === "starts_with") { + return `Invalid string: must start with "${_issue.prefix}"`; + } + if (_issue.format === "ends_with") + return `Invalid string: must end with "${_issue.suffix}"`; + if (_issue.format === "includes") + return `Invalid string: must include "${_issue.includes}"`; + if (_issue.format === "regex") + return `Invalid string: must match pattern ${_issue.pattern}`; + return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`; + } + case "not_multiple_of": + return `Invalid number: must be a multiple of ${issue2.divisor}`; + case "unrecognized_keys": + return `Unrecognized key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`; + case "invalid_key": + return `Invalid key in ${issue2.origin}`; + case "invalid_union": + return "Invalid input"; + case "invalid_element": + return `Invalid value in ${issue2.origin}`; + default: + return `Invalid input`; + } + }; +}; +function en_default2() { + return { + localeError: error() + }; +} + +// node_modules/zod/v4/core/registries.js +var _a; +var $output = Symbol("ZodOutput"); +var $input = Symbol("ZodInput"); +var $ZodRegistry = class { + constructor() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + } + add(schema, ..._meta) { + const meta3 = _meta[0]; + this._map.set(schema, meta3); + if (meta3 && typeof meta3 === "object" && "id" in meta3) { + this._idmap.set(meta3.id, schema); + } + return this; + } + clear() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + return this; + } + remove(schema) { + const meta3 = this._map.get(schema); + if (meta3 && typeof meta3 === "object" && "id" in meta3) { + this._idmap.delete(meta3.id); + } + this._map.delete(schema); + return this; + } + get(schema) { + const p = schema._zod.parent; + if (p) { + const pm = { ...this.get(p) ?? {} }; + delete pm.id; + const f = { ...pm, ...this._map.get(schema) }; + return Object.keys(f).length ? f : void 0; + } + return this._map.get(schema); + } + has(schema) { + return this._map.has(schema); + } +}; +function registry() { + return new $ZodRegistry(); +} +(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry()); +var globalRegistry = globalThis.__zod_globalRegistry; + +// node_modules/zod/v4/core/api.js +// @__NO_SIDE_EFFECTS__ +function _string(Class2, params) { + return new Class2({ + type: "string", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _email(Class2, params) { + return new Class2({ + type: "string", + format: "email", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _guid(Class2, params) { + return new Class2({ + type: "string", + format: "guid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuid(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv4(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v4", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv6(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v6", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv7(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v7", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _url(Class2, params) { + return new Class2({ + type: "string", + format: "url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _emoji2(Class2, params) { + return new Class2({ + type: "string", + format: "emoji", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _nanoid(Class2, params) { + return new Class2({ + type: "string", + format: "nanoid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid(Class2, params) { + return new Class2({ + type: "string", + format: "cuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid2(Class2, params) { + return new Class2({ + type: "string", + format: "cuid2", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ulid(Class2, params) { + return new Class2({ + type: "string", + format: "ulid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _xid(Class2, params) { + return new Class2({ + type: "string", + format: "xid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ksuid(Class2, params) { + return new Class2({ + type: "string", + format: "ksuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv4(Class2, params) { + return new Class2({ + type: "string", + format: "ipv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv6(Class2, params) { + return new Class2({ + type: "string", + format: "ipv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _mac(Class2, params) { + return new Class2({ + type: "string", + format: "mac", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv4(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv6(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64(Class2, params) { + return new Class2({ + type: "string", + format: "base64", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64url(Class2, params) { + return new Class2({ + type: "string", + format: "base64url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _e164(Class2, params) { + return new Class2({ + type: "string", + format: "e164", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _jwt(Class2, params) { + return new Class2({ + type: "string", + format: "jwt", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDateTime(Class2, params) { + return new Class2({ + type: "string", + format: "datetime", + check: "string_format", + offset: false, + local: false, + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDate(Class2, params) { + return new Class2({ + type: "string", + format: "date", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoTime(Class2, params) { + return new Class2({ + type: "string", + format: "time", + check: "string_format", + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDuration(Class2, params) { + return new Class2({ + type: "string", + format: "duration", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _number(Class2, params) { + return new Class2({ + type: "number", + checks: [], + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "safeint", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _float32(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "float32", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _float64(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "float64", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int32(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "int32", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uint32(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "uint32", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _boolean(Class2, params) { + return new Class2({ + type: "boolean", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _bigint(Class2, params) { + return new Class2({ + type: "bigint", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int64(Class2, params) { + return new Class2({ + type: "bigint", + check: "bigint_format", + abort: false, + format: "int64", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uint64(Class2, params) { + return new Class2({ + type: "bigint", + check: "bigint_format", + abort: false, + format: "uint64", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _symbol(Class2, params) { + return new Class2({ + type: "symbol", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _undefined2(Class2, params) { + return new Class2({ + type: "undefined", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _null2(Class2, params) { + return new Class2({ + type: "null", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _any(Class2) { + return new Class2({ + type: "any" + }); +} +// @__NO_SIDE_EFFECTS__ +function _unknown(Class2) { + return new Class2({ + type: "unknown" + }); +} +// @__NO_SIDE_EFFECTS__ +function _never(Class2, params) { + return new Class2({ + type: "never", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _void(Class2, params) { + return new Class2({ + type: "void", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _date(Class2, params) { + return new Class2({ + type: "date", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _nan(Class2, params) { + return new Class2({ + type: "nan", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _lt(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _lte(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _gt(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _gte(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _positive(params) { + return /* @__PURE__ */ _gt(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _negative(params) { + return /* @__PURE__ */ _lt(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _nonpositive(params) { + return /* @__PURE__ */ _lte(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _nonnegative(params) { + return /* @__PURE__ */ _gte(0, params); +} +// @__NO_SIDE_EFFECTS__ +function _multipleOf(value, params) { + return new $ZodCheckMultipleOf({ + check: "multiple_of", + ...normalizeParams(params), + value + }); +} +// @__NO_SIDE_EFFECTS__ +function _maxSize(maximum, params) { + return new $ZodCheckMaxSize({ + check: "max_size", + ...normalizeParams(params), + maximum + }); +} +// @__NO_SIDE_EFFECTS__ +function _minSize(minimum, params) { + return new $ZodCheckMinSize({ + check: "min_size", + ...normalizeParams(params), + minimum + }); +} +// @__NO_SIDE_EFFECTS__ +function _size(size, params) { + return new $ZodCheckSizeEquals({ + check: "size_equals", + ...normalizeParams(params), + size + }); +} +// @__NO_SIDE_EFFECTS__ +function _maxLength(maximum, params) { + const ch = new $ZodCheckMaxLength({ + check: "max_length", + ...normalizeParams(params), + maximum + }); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _minLength(minimum, params) { + return new $ZodCheckMinLength({ + check: "min_length", + ...normalizeParams(params), + minimum + }); +} +// @__NO_SIDE_EFFECTS__ +function _length(length, params) { + return new $ZodCheckLengthEquals({ + check: "length_equals", + ...normalizeParams(params), + length + }); +} +// @__NO_SIDE_EFFECTS__ +function _regex(pattern, params) { + return new $ZodCheckRegex({ + check: "string_format", + format: "regex", + ...normalizeParams(params), + pattern + }); +} +// @__NO_SIDE_EFFECTS__ +function _lowercase(params) { + return new $ZodCheckLowerCase({ + check: "string_format", + format: "lowercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uppercase(params) { + return new $ZodCheckUpperCase({ + check: "string_format", + format: "uppercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _includes(includes, params) { + return new $ZodCheckIncludes({ + check: "string_format", + format: "includes", + ...normalizeParams(params), + includes + }); +} +// @__NO_SIDE_EFFECTS__ +function _startsWith(prefix, params) { + return new $ZodCheckStartsWith({ + check: "string_format", + format: "starts_with", + ...normalizeParams(params), + prefix + }); +} +// @__NO_SIDE_EFFECTS__ +function _endsWith(suffix, params) { + return new $ZodCheckEndsWith({ + check: "string_format", + format: "ends_with", + ...normalizeParams(params), + suffix + }); +} +// @__NO_SIDE_EFFECTS__ +function _property(property, schema, params) { + return new $ZodCheckProperty({ + check: "property", + property, + schema, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _mime(types, params) { + return new $ZodCheckMimeType({ + check: "mime_type", + mime: types, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _overwrite(tx) { + return new $ZodCheckOverwrite({ + check: "overwrite", + tx + }); +} +// @__NO_SIDE_EFFECTS__ +function _normalize(form) { + return /* @__PURE__ */ _overwrite((input) => input.normalize(form)); +} +// @__NO_SIDE_EFFECTS__ +function _trim() { + return /* @__PURE__ */ _overwrite((input) => input.trim()); +} +// @__NO_SIDE_EFFECTS__ +function _toLowerCase() { + return /* @__PURE__ */ _overwrite((input) => input.toLowerCase()); +} +// @__NO_SIDE_EFFECTS__ +function _toUpperCase() { + return /* @__PURE__ */ _overwrite((input) => input.toUpperCase()); +} +// @__NO_SIDE_EFFECTS__ +function _slugify() { + return /* @__PURE__ */ _overwrite((input) => slugify(input)); +} +// @__NO_SIDE_EFFECTS__ +function _array(Class2, element, params) { + return new Class2({ + type: "array", + element, + // get element() { + // return element; + // }, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _file(Class2, params) { + return new Class2({ + type: "file", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _custom(Class2, fn, _params) { + const norm = normalizeParams(_params); + norm.abort ?? (norm.abort = true); + const schema = new Class2({ + type: "custom", + check: "custom", + fn, + ...norm + }); + return schema; +} +// @__NO_SIDE_EFFECTS__ +function _refine(Class2, fn, _params) { + const schema = new Class2({ + type: "custom", + check: "custom", + fn, + ...normalizeParams(_params) + }); + return schema; +} +// @__NO_SIDE_EFFECTS__ +function _superRefine(fn) { + const ch = /* @__PURE__ */ _check((payload) => { + payload.addIssue = (issue2) => { + if (typeof issue2 === "string") { + payload.issues.push(issue(issue2, payload.value, ch._zod.def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = ch); + _issue.continue ?? (_issue.continue = !ch._zod.def.abort); + payload.issues.push(issue(_issue)); + } + }; + return fn(payload.value, payload); + }); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _check(fn, params) { + const ch = new $ZodCheck({ + check: "custom", + ...normalizeParams(params) + }); + ch._zod.check = fn; + return ch; +} +// @__NO_SIDE_EFFECTS__ +function describe(description) { + const ch = new $ZodCheck({ check: "describe" }); + ch._zod.onattach = [ + (inst) => { + const existing = globalRegistry.get(inst) ?? {}; + globalRegistry.add(inst, { ...existing, description }); + } + ]; + ch._zod.check = () => { + }; + return ch; +} +// @__NO_SIDE_EFFECTS__ +function meta(metadata) { + const ch = new $ZodCheck({ check: "meta" }); + ch._zod.onattach = [ + (inst) => { + const existing = globalRegistry.get(inst) ?? {}; + globalRegistry.add(inst, { ...existing, ...metadata }); + } + ]; + ch._zod.check = () => { + }; + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _stringbool(Classes, _params) { + const params = normalizeParams(_params); + let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"]; + let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"]; + if (params.case !== "sensitive") { + truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v); + falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v); + } + const truthySet = new Set(truthyArray); + const falsySet = new Set(falsyArray); + const _Codec = Classes.Codec ?? $ZodCodec; + const _Boolean = Classes.Boolean ?? $ZodBoolean; + const _String = Classes.String ?? $ZodString; + const stringSchema = new _String({ type: "string", error: params.error }); + const booleanSchema = new _Boolean({ type: "boolean", error: params.error }); + const codec2 = new _Codec({ + type: "pipe", + in: stringSchema, + out: booleanSchema, + transform: ((input, payload) => { + let data = input; + if (params.case !== "sensitive") + data = data.toLowerCase(); + if (truthySet.has(data)) { + return true; + } else if (falsySet.has(data)) { + return false; + } else { + payload.issues.push({ + code: "invalid_value", + expected: "stringbool", + values: [...truthySet, ...falsySet], + input: payload.value, + inst: codec2, + continue: false + }); + return {}; + } + }), + reverseTransform: ((input, _payload) => { + if (input === true) { + return truthyArray[0] || "true"; + } else { + return falsyArray[0] || "false"; + } + }), + error: params.error + }); + return codec2; +} +// @__NO_SIDE_EFFECTS__ +function _stringFormat(Class2, format, fnOrRegex, _params = {}) { + const params = normalizeParams(_params); + const def = { + ...normalizeParams(_params), + check: "string_format", + type: "string", + format, + fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val), + ...params + }; + if (fnOrRegex instanceof RegExp) { + def.pattern = fnOrRegex; + } + const inst = new Class2(def); + return inst; +} + +// node_modules/zod/v4/core/to-json-schema.js +function initializeContext(params) { + let target = params?.target ?? "draft-2020-12"; + if (target === "draft-4") + target = "draft-04"; + if (target === "draft-7") + target = "draft-07"; + return { + processors: params.processors ?? {}, + metadataRegistry: params?.metadata ?? globalRegistry, + target, + unrepresentable: params?.unrepresentable ?? "throw", + override: params?.override ?? (() => { + }), + io: params?.io ?? "output", + counter: 0, + seen: /* @__PURE__ */ new Map(), + cycles: params?.cycles ?? "ref", + reused: params?.reused ?? "inline", + external: params?.external ?? void 0 + }; +} +function process2(schema, ctx, _params = { path: [], schemaPath: [] }) { + var _a2; + const def = schema._zod.def; + const seen = ctx.seen.get(schema); + if (seen) { + seen.count++; + const isCycle = _params.schemaPath.includes(schema); + if (isCycle) { + seen.cycle = _params.path; + } + return seen.schema; + } + const result = { schema: {}, count: 1, cycle: void 0, path: _params.path }; + ctx.seen.set(schema, result); + const overrideSchema = schema._zod.toJSONSchema?.(); + if (overrideSchema) { + result.schema = overrideSchema; + } else { + const params = { + ..._params, + schemaPath: [..._params.schemaPath, schema], + path: _params.path + }; + if (schema._zod.processJSONSchema) { + schema._zod.processJSONSchema(ctx, result.schema, params); + } else { + const _json = result.schema; + const processor = ctx.processors[def.type]; + if (!processor) { + throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`); + } + processor(schema, ctx, _json, params); + } + const parent = schema._zod.parent; + if (parent) { + if (!result.ref) + result.ref = parent; + process2(parent, ctx, params); + ctx.seen.get(parent).isParent = true; + } + } + const meta3 = ctx.metadataRegistry.get(schema); + if (meta3) + Object.assign(result.schema, meta3); + if (ctx.io === "input" && isTransforming(schema)) { + delete result.schema.examples; + delete result.schema.default; + } + if (ctx.io === "input" && result.schema._prefault) + (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault); + delete result.schema._prefault; + const _result = ctx.seen.get(schema); + return _result.schema; +} +function extractDefs(ctx, schema) { + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const idToSchema = /* @__PURE__ */ new Map(); + for (const entry of ctx.seen.entries()) { + const id = ctx.metadataRegistry.get(entry[0])?.id; + if (id) { + const existing = idToSchema.get(id); + if (existing && existing !== entry[0]) { + throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`); + } + idToSchema.set(id, entry[0]); + } + } + const makeURI = (entry) => { + const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions"; + if (ctx.external) { + const externalId = ctx.external.registry.get(entry[0])?.id; + const uriGenerator = ctx.external.uri ?? ((id2) => id2); + if (externalId) { + return { ref: uriGenerator(externalId) }; + } + const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`; + entry[1].defId = id; + return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` }; + } + if (entry[1] === root) { + return { ref: "#" }; + } + const uriPrefix = `#`; + const defUriPrefix = `${uriPrefix}/${defsSegment}/`; + const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`; + return { defId, ref: defUriPrefix + defId }; + }; + const extractToDef = (entry) => { + if (entry[1].schema.$ref) { + return; + } + const seen = entry[1]; + const { ref, defId } = makeURI(entry); + seen.def = { ...seen.schema }; + if (defId) + seen.defId = defId; + const schema2 = seen.schema; + for (const key in schema2) { + delete schema2[key]; + } + schema2.$ref = ref; + }; + if (ctx.cycles === "throw") { + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.cycle) { + throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/ + +Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`); + } + } + } + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (schema === entry[0]) { + extractToDef(entry); + continue; + } + if (ctx.external) { + const ext = ctx.external.registry.get(entry[0])?.id; + if (schema !== entry[0] && ext) { + extractToDef(entry); + continue; + } + } + const id = ctx.metadataRegistry.get(entry[0])?.id; + if (id) { + extractToDef(entry); + continue; + } + if (seen.cycle) { + extractToDef(entry); + continue; + } + if (seen.count > 1) { + if (ctx.reused === "ref") { + extractToDef(entry); + continue; + } + } + } +} +function finalize(ctx, schema) { + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const flattenRef = (zodSchema) => { + const seen = ctx.seen.get(zodSchema); + if (seen.ref === null) + return; + const schema2 = seen.def ?? seen.schema; + const _cached = { ...schema2 }; + const ref = seen.ref; + seen.ref = null; + if (ref) { + flattenRef(ref); + const refSeen = ctx.seen.get(ref); + const refSchema = refSeen.schema; + if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) { + schema2.allOf = schema2.allOf ?? []; + schema2.allOf.push(refSchema); + } else { + Object.assign(schema2, refSchema); + } + Object.assign(schema2, _cached); + const isParentRef = zodSchema._zod.parent === ref; + if (isParentRef) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (!(key in _cached)) { + delete schema2[key]; + } + } + } + if (refSchema.$ref && refSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) { + delete schema2[key]; + } + } + } + } + const parent = zodSchema._zod.parent; + if (parent && parent !== ref) { + flattenRef(parent); + const parentSeen = ctx.seen.get(parent); + if (parentSeen?.schema.$ref) { + schema2.$ref = parentSeen.schema.$ref; + if (parentSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) { + delete schema2[key]; + } + } + } + } + } + ctx.override({ + zodSchema, + jsonSchema: schema2, + path: seen.path ?? [] + }); + }; + for (const entry of [...ctx.seen.entries()].reverse()) { + flattenRef(entry[0]); + } + const result = {}; + if (ctx.target === "draft-2020-12") { + result.$schema = "https://json-schema.org/draft/2020-12/schema"; + } else if (ctx.target === "draft-07") { + result.$schema = "http://json-schema.org/draft-07/schema#"; + } else if (ctx.target === "draft-04") { + result.$schema = "http://json-schema.org/draft-04/schema#"; + } else if (ctx.target === "openapi-3.0") { + } else { + } + if (ctx.external?.uri) { + const id = ctx.external.registry.get(schema)?.id; + if (!id) + throw new Error("Schema is missing an `id` property"); + result.$id = ctx.external.uri(id); + } + Object.assign(result, root.def ?? root.schema); + const defs = ctx.external?.defs ?? {}; + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.def && seen.defId) { + defs[seen.defId] = seen.def; + } + } + if (ctx.external) { + } else { + if (Object.keys(defs).length > 0) { + if (ctx.target === "draft-2020-12") { + result.$defs = defs; + } else { + result.definitions = defs; + } + } + } + try { + const finalized = JSON.parse(JSON.stringify(result)); + Object.defineProperty(finalized, "~standard", { + value: { + ...schema["~standard"], + jsonSchema: { + input: createStandardJSONSchemaMethod(schema, "input", ctx.processors), + output: createStandardJSONSchemaMethod(schema, "output", ctx.processors) + } + }, + enumerable: false, + writable: false + }); + return finalized; + } catch (_err) { + throw new Error("Error converting schema to JSON."); + } +} +function isTransforming(_schema, _ctx) { + const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() }; + if (ctx.seen.has(_schema)) + return false; + ctx.seen.add(_schema); + const def = _schema._zod.def; + if (def.type === "transform") + return true; + if (def.type === "array") + return isTransforming(def.element, ctx); + if (def.type === "set") + return isTransforming(def.valueType, ctx); + if (def.type === "lazy") + return isTransforming(def.getter(), ctx); + if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") { + return isTransforming(def.innerType, ctx); + } + if (def.type === "intersection") { + return isTransforming(def.left, ctx) || isTransforming(def.right, ctx); + } + if (def.type === "record" || def.type === "map") { + return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx); + } + if (def.type === "pipe") { + return isTransforming(def.in, ctx) || isTransforming(def.out, ctx); + } + if (def.type === "object") { + for (const key in def.shape) { + if (isTransforming(def.shape[key], ctx)) + return true; + } + return false; + } + if (def.type === "union") { + for (const option of def.options) { + if (isTransforming(option, ctx)) + return true; + } + return false; + } + if (def.type === "tuple") { + for (const item of def.items) { + if (isTransforming(item, ctx)) + return true; + } + if (def.rest && isTransforming(def.rest, ctx)) + return true; + return false; + } + return false; +} +var createToJSONSchemaMethod = (schema, processors = {}) => (params) => { + const ctx = initializeContext({ ...params, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; +var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => { + const { libraryOptions, target } = params ?? {}; + const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; + +// node_modules/zod/v4/core/json-schema-processors.js +var formatMap = { + guid: "uuid", + url: "uri", + datetime: "date-time", + json_string: "json-string", + regex: "" + // do not set +}; +var stringProcessor = (schema, ctx, _json, _params) => { + const json2 = _json; + json2.type = "string"; + const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag; + if (typeof minimum === "number") + json2.minLength = minimum; + if (typeof maximum === "number") + json2.maxLength = maximum; + if (format) { + json2.format = formatMap[format] ?? format; + if (json2.format === "") + delete json2.format; + if (format === "time") { + delete json2.format; + } + } + if (contentEncoding) + json2.contentEncoding = contentEncoding; + if (patterns && patterns.size > 0) { + const regexes = [...patterns]; + if (regexes.length === 1) + json2.pattern = regexes[0].source; + else if (regexes.length > 1) { + json2.allOf = [ + ...regexes.map((regex) => ({ + ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {}, + pattern: regex.source + })) + ]; + } + } +}; +var numberProcessor = (schema, ctx, _json, _params) => { + const json2 = _json; + const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag; + if (typeof format === "string" && format.includes("int")) + json2.type = "integer"; + else + json2.type = "number"; + if (typeof exclusiveMinimum === "number") { + if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") { + json2.minimum = exclusiveMinimum; + json2.exclusiveMinimum = true; + } else { + json2.exclusiveMinimum = exclusiveMinimum; + } + } + if (typeof minimum === "number") { + json2.minimum = minimum; + if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") { + if (exclusiveMinimum >= minimum) + delete json2.minimum; + else + delete json2.exclusiveMinimum; + } + } + if (typeof exclusiveMaximum === "number") { + if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") { + json2.maximum = exclusiveMaximum; + json2.exclusiveMaximum = true; + } else { + json2.exclusiveMaximum = exclusiveMaximum; + } + } + if (typeof maximum === "number") { + json2.maximum = maximum; + if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") { + if (exclusiveMaximum <= maximum) + delete json2.maximum; + else + delete json2.exclusiveMaximum; + } + } + if (typeof multipleOf === "number") + json2.multipleOf = multipleOf; +}; +var booleanProcessor = (_schema, _ctx, json2, _params) => { + json2.type = "boolean"; +}; +var bigintProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("BigInt cannot be represented in JSON Schema"); + } +}; +var symbolProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Symbols cannot be represented in JSON Schema"); + } +}; +var nullProcessor = (_schema, ctx, json2, _params) => { + if (ctx.target === "openapi-3.0") { + json2.type = "string"; + json2.nullable = true; + json2.enum = [null]; + } else { + json2.type = "null"; + } +}; +var undefinedProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Undefined cannot be represented in JSON Schema"); + } +}; +var voidProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Void cannot be represented in JSON Schema"); + } +}; +var neverProcessor = (_schema, _ctx, json2, _params) => { + json2.not = {}; +}; +var anyProcessor = (_schema, _ctx, _json, _params) => { +}; +var unknownProcessor = (_schema, _ctx, _json, _params) => { +}; +var dateProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Date cannot be represented in JSON Schema"); + } +}; +var enumProcessor = (schema, _ctx, json2, _params) => { + const def = schema._zod.def; + const values = getEnumValues(def.entries); + if (values.every((v) => typeof v === "number")) + json2.type = "number"; + if (values.every((v) => typeof v === "string")) + json2.type = "string"; + json2.enum = values; +}; +var literalProcessor = (schema, ctx, json2, _params) => { + const def = schema._zod.def; + const vals = []; + for (const val of def.values) { + if (val === void 0) { + if (ctx.unrepresentable === "throw") { + throw new Error("Literal `undefined` cannot be represented in JSON Schema"); + } else { + } + } else if (typeof val === "bigint") { + if (ctx.unrepresentable === "throw") { + throw new Error("BigInt literals cannot be represented in JSON Schema"); + } else { + vals.push(Number(val)); + } + } else { + vals.push(val); + } + } + if (vals.length === 0) { + } else if (vals.length === 1) { + const val = vals[0]; + json2.type = val === null ? "null" : typeof val; + if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") { + json2.enum = [val]; + } else { + json2.const = val; + } + } else { + if (vals.every((v) => typeof v === "number")) + json2.type = "number"; + if (vals.every((v) => typeof v === "string")) + json2.type = "string"; + if (vals.every((v) => typeof v === "boolean")) + json2.type = "boolean"; + if (vals.every((v) => v === null)) + json2.type = "null"; + json2.enum = vals; + } +}; +var nanProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("NaN cannot be represented in JSON Schema"); + } +}; +var templateLiteralProcessor = (schema, _ctx, json2, _params) => { + const _json = json2; + const pattern = schema._zod.pattern; + if (!pattern) + throw new Error("Pattern not found in template literal"); + _json.type = "string"; + _json.pattern = pattern.source; +}; +var fileProcessor = (schema, _ctx, json2, _params) => { + const _json = json2; + const file2 = { + type: "string", + format: "binary", + contentEncoding: "binary" + }; + const { minimum, maximum, mime } = schema._zod.bag; + if (minimum !== void 0) + file2.minLength = minimum; + if (maximum !== void 0) + file2.maxLength = maximum; + if (mime) { + if (mime.length === 1) { + file2.contentMediaType = mime[0]; + Object.assign(_json, file2); + } else { + Object.assign(_json, file2); + _json.anyOf = mime.map((m) => ({ contentMediaType: m })); + } + } else { + Object.assign(_json, file2); + } +}; +var successProcessor = (_schema, _ctx, json2, _params) => { + json2.type = "boolean"; +}; +var customProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Custom types cannot be represented in JSON Schema"); + } +}; +var functionProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Function types cannot be represented in JSON Schema"); + } +}; +var transformProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Transforms cannot be represented in JSON Schema"); + } +}; +var mapProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Map cannot be represented in JSON Schema"); + } +}; +var setProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Set cannot be represented in JSON Schema"); + } +}; +var arrayProcessor = (schema, ctx, _json, params) => { + const json2 = _json; + const def = schema._zod.def; + const { minimum, maximum } = schema._zod.bag; + if (typeof minimum === "number") + json2.minItems = minimum; + if (typeof maximum === "number") + json2.maxItems = maximum; + json2.type = "array"; + json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] }); +}; +var objectProcessor = (schema, ctx, _json, params) => { + const json2 = _json; + const def = schema._zod.def; + json2.type = "object"; + json2.properties = {}; + const shape = def.shape; + for (const key in shape) { + json2.properties[key] = process2(shape[key], ctx, { + ...params, + path: [...params.path, "properties", key] + }); + } + const allKeys = new Set(Object.keys(shape)); + const requiredKeys = new Set([...allKeys].filter((key) => { + const v = def.shape[key]._zod; + if (ctx.io === "input") { + return v.optin === void 0; + } else { + return v.optout === void 0; + } + })); + if (requiredKeys.size > 0) { + json2.required = Array.from(requiredKeys); + } + if (def.catchall?._zod.def.type === "never") { + json2.additionalProperties = false; + } else if (!def.catchall) { + if (ctx.io === "output") + json2.additionalProperties = false; + } else if (def.catchall) { + json2.additionalProperties = process2(def.catchall, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } +}; +var unionProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + const isExclusive = def.inclusive === false; + const options = def.options.map((x, i) => process2(x, ctx, { + ...params, + path: [...params.path, isExclusive ? "oneOf" : "anyOf", i] + })); + if (isExclusive) { + json2.oneOf = options; + } else { + json2.anyOf = options; + } +}; +var intersectionProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + const a = process2(def.left, ctx, { + ...params, + path: [...params.path, "allOf", 0] + }); + const b = process2(def.right, ctx, { + ...params, + path: [...params.path, "allOf", 1] + }); + const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1; + const allOf = [ + ...isSimpleIntersection(a) ? a.allOf : [a], + ...isSimpleIntersection(b) ? b.allOf : [b] + ]; + json2.allOf = allOf; +}; +var tupleProcessor = (schema, ctx, _json, params) => { + const json2 = _json; + const def = schema._zod.def; + json2.type = "array"; + const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items"; + const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems"; + const prefixItems = def.items.map((x, i) => process2(x, ctx, { + ...params, + path: [...params.path, prefixPath, i] + })); + const rest = def.rest ? process2(def.rest, ctx, { + ...params, + path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []] + }) : null; + if (ctx.target === "draft-2020-12") { + json2.prefixItems = prefixItems; + if (rest) { + json2.items = rest; + } + } else if (ctx.target === "openapi-3.0") { + json2.items = { + anyOf: prefixItems + }; + if (rest) { + json2.items.anyOf.push(rest); + } + json2.minItems = prefixItems.length; + if (!rest) { + json2.maxItems = prefixItems.length; + } + } else { + json2.items = prefixItems; + if (rest) { + json2.additionalItems = rest; + } + } + const { minimum, maximum } = schema._zod.bag; + if (typeof minimum === "number") + json2.minItems = minimum; + if (typeof maximum === "number") + json2.maxItems = maximum; +}; +var recordProcessor = (schema, ctx, _json, params) => { + const json2 = _json; + const def = schema._zod.def; + json2.type = "object"; + const keyType = def.keyType; + const keyBag = keyType._zod.bag; + const patterns = keyBag?.patterns; + if (def.mode === "loose" && patterns && patterns.size > 0) { + const valueSchema = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "patternProperties", "*"] + }); + json2.patternProperties = {}; + for (const pattern of patterns) { + json2.patternProperties[pattern.source] = valueSchema; + } + } else { + if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") { + json2.propertyNames = process2(def.keyType, ctx, { + ...params, + path: [...params.path, "propertyNames"] + }); + } + json2.additionalProperties = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } + const keyValues = keyType._zod.values; + if (keyValues) { + const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number"); + if (validKeyValues.length > 0) { + json2.required = validKeyValues; + } + } +}; +var nullableProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + const inner = process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + if (ctx.target === "openapi-3.0") { + seen.ref = def.innerType; + json2.nullable = true; + } else { + json2.anyOf = [inner, { type: "null" }]; + } +}; +var nonoptionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var defaultProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json2.default = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var prefaultProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + if (ctx.io === "input") + json2._prefault = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var catchProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + let catchValue; + try { + catchValue = def.catchValue(void 0); + } catch { + throw new Error("Dynamic catch values are not supported in JSON Schema"); + } + json2.default = catchValue; +}; +var pipeProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out; + process2(innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = innerType; +}; +var readonlyProcessor = (schema, ctx, json2, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json2.readOnly = true; +}; +var promiseProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var optionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var lazyProcessor = (schema, ctx, _json, params) => { + const innerType = schema._zod.innerType; + process2(innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = innerType; +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js +function isZ4Schema(s) { + const schema = s; + return !!schema._zod; +} +function safeParse2(schema, data) { + if (isZ4Schema(schema)) { + const result2 = safeParse(schema, data); + return result2; + } + const v3Schema = schema; + const result = v3Schema.safeParse(data); + return result; +} +function getObjectShape(schema) { + if (!schema) + return void 0; + let rawShape; + if (isZ4Schema(schema)) { + const v4Schema = schema; + rawShape = v4Schema._zod?.def?.shape; + } else { + const v3Schema = schema; + rawShape = v3Schema.shape; + } + if (!rawShape) + return void 0; + if (typeof rawShape === "function") { + try { + return rawShape(); + } catch { + return void 0; + } + } + return rawShape; +} +function getLiteralValue(schema) { + if (isZ4Schema(schema)) { + const v4Schema = schema; + const def2 = v4Schema._zod?.def; + if (def2) { + if (def2.value !== void 0) + return def2.value; + if (Array.isArray(def2.values) && def2.values.length > 0) { + return def2.values[0]; + } + } + } + const v3Schema = schema; + const def = v3Schema._def; + if (def) { + if (def.value !== void 0) + return def.value; + if (Array.isArray(def.values) && def.values.length > 0) { + return def.values[0]; + } + } + const directValue = schema.value; + if (directValue !== void 0) + return directValue; + return void 0; +} + +// node_modules/zod/v4/classic/schemas.js +var schemas_exports3 = {}; +__export(schemas_exports3, { + ZodAny: () => ZodAny2, + ZodArray: () => ZodArray2, + ZodBase64: () => ZodBase64, + ZodBase64URL: () => ZodBase64URL, + ZodBigInt: () => ZodBigInt2, + ZodBigIntFormat: () => ZodBigIntFormat, + ZodBoolean: () => ZodBoolean2, + ZodCIDRv4: () => ZodCIDRv4, + ZodCIDRv6: () => ZodCIDRv6, + ZodCUID: () => ZodCUID, + ZodCUID2: () => ZodCUID2, + ZodCatch: () => ZodCatch2, + ZodCodec: () => ZodCodec, + ZodCustom: () => ZodCustom, + ZodCustomStringFormat: () => ZodCustomStringFormat, + ZodDate: () => ZodDate2, + ZodDefault: () => ZodDefault2, + ZodDiscriminatedUnion: () => ZodDiscriminatedUnion2, + ZodE164: () => ZodE164, + ZodEmail: () => ZodEmail, + ZodEmoji: () => ZodEmoji, + ZodEnum: () => ZodEnum2, + ZodExactOptional: () => ZodExactOptional, + ZodFile: () => ZodFile, + ZodFunction: () => ZodFunction2, + ZodGUID: () => ZodGUID, + ZodIPv4: () => ZodIPv4, + ZodIPv6: () => ZodIPv6, + ZodIntersection: () => ZodIntersection2, + ZodJWT: () => ZodJWT, + ZodKSUID: () => ZodKSUID, + ZodLazy: () => ZodLazy2, + ZodLiteral: () => ZodLiteral2, + ZodMAC: () => ZodMAC, + ZodMap: () => ZodMap2, + ZodNaN: () => ZodNaN2, + ZodNanoID: () => ZodNanoID, + ZodNever: () => ZodNever2, + ZodNonOptional: () => ZodNonOptional, + ZodNull: () => ZodNull2, + ZodNullable: () => ZodNullable2, + ZodNumber: () => ZodNumber2, + ZodNumberFormat: () => ZodNumberFormat, + ZodObject: () => ZodObject2, + ZodOptional: () => ZodOptional2, + ZodPipe: () => ZodPipe, + ZodPrefault: () => ZodPrefault, + ZodPromise: () => ZodPromise2, + ZodReadonly: () => ZodReadonly2, + ZodRecord: () => ZodRecord2, + ZodSet: () => ZodSet2, + ZodString: () => ZodString2, + ZodStringFormat: () => ZodStringFormat, + ZodSuccess: () => ZodSuccess, + ZodSymbol: () => ZodSymbol2, + ZodTemplateLiteral: () => ZodTemplateLiteral, + ZodTransform: () => ZodTransform, + ZodTuple: () => ZodTuple2, + ZodType: () => ZodType2, + ZodULID: () => ZodULID, + ZodURL: () => ZodURL, + ZodUUID: () => ZodUUID, + ZodUndefined: () => ZodUndefined2, + ZodUnion: () => ZodUnion2, + ZodUnknown: () => ZodUnknown2, + ZodVoid: () => ZodVoid2, + ZodXID: () => ZodXID, + ZodXor: () => ZodXor, + _ZodString: () => _ZodString, + _default: () => _default, + _function: () => _function, + any: () => any, + array: () => array, + base64: () => base642, + base64url: () => base64url2, + bigint: () => bigint2, + boolean: () => boolean2, + catch: () => _catch, + check: () => check, + cidrv4: () => cidrv42, + cidrv6: () => cidrv62, + codec: () => codec, + cuid: () => cuid3, + cuid2: () => cuid22, + custom: () => custom, + date: () => date3, + describe: () => describe2, + discriminatedUnion: () => discriminatedUnion, + e164: () => e1642, + email: () => email2, + emoji: () => emoji2, + enum: () => _enum, + exactOptional: () => exactOptional, + file: () => file, + float32: () => float32, + float64: () => float64, + function: () => _function, + guid: () => guid2, + hash: () => hash, + hex: () => hex2, + hostname: () => hostname2, + httpUrl: () => httpUrl, + instanceof: () => _instanceof, + int: () => int, + int32: () => int32, + int64: () => int64, + intersection: () => intersection, + ipv4: () => ipv42, + ipv6: () => ipv62, + json: () => json, + jwt: () => jwt, + keyof: () => keyof, + ksuid: () => ksuid2, + lazy: () => lazy, + literal: () => literal, + looseObject: () => looseObject, + looseRecord: () => looseRecord, + mac: () => mac2, + map: () => map, + meta: () => meta2, + nan: () => nan, + nanoid: () => nanoid2, + nativeEnum: () => nativeEnum, + never: () => never, + nonoptional: () => nonoptional, + null: () => _null3, + nullable: () => nullable, + nullish: () => nullish2, + number: () => number2, + object: () => object2, + optional: () => optional, + partialRecord: () => partialRecord, + pipe: () => pipe, + prefault: () => prefault, + preprocess: () => preprocess, + promise: () => promise, + readonly: () => readonly, + record: () => record, + refine: () => refine, + set: () => set, + strictObject: () => strictObject, + string: () => string2, + stringFormat: () => stringFormat, + stringbool: () => stringbool, + success: () => success, + superRefine: () => superRefine, + symbol: () => symbol, + templateLiteral: () => templateLiteral, + transform: () => transform, + tuple: () => tuple, + uint32: () => uint32, + uint64: () => uint64, + ulid: () => ulid2, + undefined: () => _undefined3, + union: () => union, + unknown: () => unknown, + url: () => url, + uuid: () => uuid2, + uuidv4: () => uuidv4, + uuidv6: () => uuidv6, + uuidv7: () => uuidv7, + void: () => _void2, + xid: () => xid2, + xor: () => xor +}); + +// node_modules/zod/v4/classic/checks.js +var checks_exports2 = {}; +__export(checks_exports2, { + endsWith: () => _endsWith, + gt: () => _gt, + gte: () => _gte, + includes: () => _includes, + length: () => _length, + lowercase: () => _lowercase, + lt: () => _lt, + lte: () => _lte, + maxLength: () => _maxLength, + maxSize: () => _maxSize, + mime: () => _mime, + minLength: () => _minLength, + minSize: () => _minSize, + multipleOf: () => _multipleOf, + negative: () => _negative, + nonnegative: () => _nonnegative, + nonpositive: () => _nonpositive, + normalize: () => _normalize, + overwrite: () => _overwrite, + positive: () => _positive, + property: () => _property, + regex: () => _regex, + size: () => _size, + slugify: () => _slugify, + startsWith: () => _startsWith, + toLowerCase: () => _toLowerCase, + toUpperCase: () => _toUpperCase, + trim: () => _trim, + uppercase: () => _uppercase +}); + +// node_modules/zod/v4/classic/iso.js +var iso_exports2 = {}; +__export(iso_exports2, { + ZodISODate: () => ZodISODate, + ZodISODateTime: () => ZodISODateTime, + ZodISODuration: () => ZodISODuration, + ZodISOTime: () => ZodISOTime, + date: () => date2, + datetime: () => datetime2, + duration: () => duration2, + time: () => time2 +}); +var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => { + $ZodISODateTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function datetime2(params) { + return _isoDateTime(ZodISODateTime, params); +} +var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => { + $ZodISODate.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function date2(params) { + return _isoDate(ZodISODate, params); +} +var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => { + $ZodISOTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function time2(params) { + return _isoTime(ZodISOTime, params); +} +var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => { + $ZodISODuration.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function duration2(params) { + return _isoDuration(ZodISODuration, params); +} + +// node_modules/zod/v4/classic/errors.js +var initializer2 = (inst, issues) => { + $ZodError.init(inst, issues); + inst.name = "ZodError"; + Object.defineProperties(inst, { + format: { + value: (mapper) => formatError(inst, mapper) + // enumerable: false, + }, + flatten: { + value: (mapper) => flattenError(inst, mapper) + // enumerable: false, + }, + addIssue: { + value: (issue2) => { + inst.issues.push(issue2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + addIssues: { + value: (issues2) => { + inst.issues.push(...issues2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + isEmpty: { + get() { + return inst.issues.length === 0; + } + // enumerable: false, + } + }); +}; +var ZodError2 = $constructor("ZodError", initializer2); +var ZodRealError = $constructor("ZodError", initializer2, { + Parent: Error +}); + +// node_modules/zod/v4/classic/parse.js +var parse2 = /* @__PURE__ */ _parse(ZodRealError); +var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError); +var safeParse3 = /* @__PURE__ */ _safeParse(ZodRealError); +var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError); +var encode2 = /* @__PURE__ */ _encode(ZodRealError); +var decode2 = /* @__PURE__ */ _decode(ZodRealError); +var encodeAsync2 = /* @__PURE__ */ _encodeAsync(ZodRealError); +var decodeAsync2 = /* @__PURE__ */ _decodeAsync(ZodRealError); +var safeEncode2 = /* @__PURE__ */ _safeEncode(ZodRealError); +var safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError); +var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError); +var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError); + +// node_modules/zod/v4/classic/schemas.js +var ZodType2 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => { + $ZodType.init(inst, def); + Object.assign(inst["~standard"], { + jsonSchema: { + input: createStandardJSONSchemaMethod(inst, "input"), + output: createStandardJSONSchemaMethod(inst, "output") + } + }); + inst.toJSONSchema = createToJSONSchemaMethod(inst, {}); + inst.def = def; + inst.type = def.type; + Object.defineProperty(inst, "_def", { value: def }); + inst.check = (...checks) => { + return inst.clone(util_exports.mergeDefs(def, { + checks: [ + ...def.checks ?? [], + ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch) + ] + }), { + parent: true + }); + }; + inst.with = inst.check; + inst.clone = (def2, params) => clone(inst, def2, params); + inst.brand = () => inst; + inst.register = ((reg, meta3) => { + reg.add(inst, meta3); + return inst; + }); + inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse }); + inst.safeParse = (data, params) => safeParse3(inst, data, params); + inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync }); + inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params); + inst.spa = inst.safeParseAsync; + inst.encode = (data, params) => encode2(inst, data, params); + inst.decode = (data, params) => decode2(inst, data, params); + inst.encodeAsync = async (data, params) => encodeAsync2(inst, data, params); + inst.decodeAsync = async (data, params) => decodeAsync2(inst, data, params); + inst.safeEncode = (data, params) => safeEncode2(inst, data, params); + inst.safeDecode = (data, params) => safeDecode2(inst, data, params); + inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params); + inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params); + inst.refine = (check2, params) => inst.check(refine(check2, params)); + inst.superRefine = (refinement) => inst.check(superRefine(refinement)); + inst.overwrite = (fn) => inst.check(_overwrite(fn)); + inst.optional = () => optional(inst); + inst.exactOptional = () => exactOptional(inst); + inst.nullable = () => nullable(inst); + inst.nullish = () => optional(nullable(inst)); + inst.nonoptional = (params) => nonoptional(inst, params); + inst.array = () => array(inst); + inst.or = (arg) => union([inst, arg]); + inst.and = (arg) => intersection(inst, arg); + inst.transform = (tx) => pipe(inst, transform(tx)); + inst.default = (def2) => _default(inst, def2); + inst.prefault = (def2) => prefault(inst, def2); + inst.catch = (params) => _catch(inst, params); + inst.pipe = (target) => pipe(inst, target); + inst.readonly = () => readonly(inst); + inst.describe = (description) => { + const cl = inst.clone(); + globalRegistry.add(cl, { description }); + return cl; + }; + Object.defineProperty(inst, "description", { + get() { + return globalRegistry.get(inst)?.description; + }, + configurable: true + }); + inst.meta = (...args) => { + if (args.length === 0) { + return globalRegistry.get(inst); + } + const cl = inst.clone(); + globalRegistry.add(cl, args[0]); + return cl; + }; + inst.isOptional = () => inst.safeParse(void 0).success; + inst.isNullable = () => inst.safeParse(null).success; + inst.apply = (fn) => fn(inst); + return inst; +}); +var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => { + $ZodString.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params); + const bag = inst._zod.bag; + inst.format = bag.format ?? null; + inst.minLength = bag.minimum ?? null; + inst.maxLength = bag.maximum ?? null; + inst.regex = (...args) => inst.check(_regex(...args)); + inst.includes = (...args) => inst.check(_includes(...args)); + inst.startsWith = (...args) => inst.check(_startsWith(...args)); + inst.endsWith = (...args) => inst.check(_endsWith(...args)); + inst.min = (...args) => inst.check(_minLength(...args)); + inst.max = (...args) => inst.check(_maxLength(...args)); + inst.length = (...args) => inst.check(_length(...args)); + inst.nonempty = (...args) => inst.check(_minLength(1, ...args)); + inst.lowercase = (params) => inst.check(_lowercase(params)); + inst.uppercase = (params) => inst.check(_uppercase(params)); + inst.trim = () => inst.check(_trim()); + inst.normalize = (...args) => inst.check(_normalize(...args)); + inst.toLowerCase = () => inst.check(_toLowerCase()); + inst.toUpperCase = () => inst.check(_toUpperCase()); + inst.slugify = () => inst.check(_slugify()); +}); +var ZodString2 = /* @__PURE__ */ $constructor("ZodString", (inst, def) => { + $ZodString.init(inst, def); + _ZodString.init(inst, def); + inst.email = (params) => inst.check(_email(ZodEmail, params)); + inst.url = (params) => inst.check(_url(ZodURL, params)); + inst.jwt = (params) => inst.check(_jwt(ZodJWT, params)); + inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.uuid = (params) => inst.check(_uuid(ZodUUID, params)); + inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params)); + inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params)); + inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params)); + inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.cuid = (params) => inst.check(_cuid(ZodCUID, params)); + inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params)); + inst.ulid = (params) => inst.check(_ulid(ZodULID, params)); + inst.base64 = (params) => inst.check(_base64(ZodBase64, params)); + inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params)); + inst.xid = (params) => inst.check(_xid(ZodXID, params)); + inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params)); + inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params)); + inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params)); + inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params)); + inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params)); + inst.e164 = (params) => inst.check(_e164(ZodE164, params)); + inst.datetime = (params) => inst.check(datetime2(params)); + inst.date = (params) => inst.check(date2(params)); + inst.time = (params) => inst.check(time2(params)); + inst.duration = (params) => inst.check(duration2(params)); +}); +function string2(params) { + return _string(ZodString2, params); +} +var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + _ZodString.init(inst, def); +}); +var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => { + $ZodEmail.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function email2(params) { + return _email(ZodEmail, params); +} +var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => { + $ZodGUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function guid2(params) { + return _guid(ZodGUID, params); +} +var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => { + $ZodUUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function uuid2(params) { + return _uuid(ZodUUID, params); +} +function uuidv4(params) { + return _uuidv4(ZodUUID, params); +} +function uuidv6(params) { + return _uuidv6(ZodUUID, params); +} +function uuidv7(params) { + return _uuidv7(ZodUUID, params); +} +var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => { + $ZodURL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function url(params) { + return _url(ZodURL, params); +} +function httpUrl(params) { + return _url(ZodURL, { + protocol: /^https?$/, + hostname: regexes_exports.domain, + ...util_exports.normalizeParams(params) + }); +} +var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => { + $ZodEmoji.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function emoji2(params) { + return _emoji2(ZodEmoji, params); +} +var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => { + $ZodNanoID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function nanoid2(params) { + return _nanoid(ZodNanoID, params); +} +var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => { + $ZodCUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cuid3(params) { + return _cuid(ZodCUID, params); +} +var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => { + $ZodCUID2.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cuid22(params) { + return _cuid2(ZodCUID2, params); +} +var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => { + $ZodULID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ulid2(params) { + return _ulid(ZodULID, params); +} +var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => { + $ZodXID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function xid2(params) { + return _xid(ZodXID, params); +} +var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => { + $ZodKSUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ksuid2(params) { + return _ksuid(ZodKSUID, params); +} +var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => { + $ZodIPv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ipv42(params) { + return _ipv4(ZodIPv4, params); +} +var ZodMAC = /* @__PURE__ */ $constructor("ZodMAC", (inst, def) => { + $ZodMAC.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function mac2(params) { + return _mac(ZodMAC, params); +} +var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => { + $ZodIPv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function ipv62(params) { + return _ipv6(ZodIPv6, params); +} +var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => { + $ZodCIDRv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cidrv42(params) { + return _cidrv4(ZodCIDRv4, params); +} +var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => { + $ZodCIDRv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function cidrv62(params) { + return _cidrv6(ZodCIDRv6, params); +} +var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => { + $ZodBase64.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function base642(params) { + return _base64(ZodBase64, params); +} +var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => { + $ZodBase64URL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function base64url2(params) { + return _base64url(ZodBase64URL, params); +} +var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => { + $ZodE164.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function e1642(params) { + return _e164(ZodE164, params); +} +var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => { + $ZodJWT.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function jwt(params) { + return _jwt(ZodJWT, params); +} +var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat", (inst, def) => { + $ZodCustomStringFormat.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function stringFormat(format, fnOrRegex, _params = {}) { + return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params); +} +function hostname2(_params) { + return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params); +} +function hex2(_params) { + return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params); +} +function hash(alg, params) { + const enc = params?.enc ?? "hex"; + const format = `${alg}_${enc}`; + const regex = regexes_exports[format]; + if (!regex) + throw new Error(`Unrecognized hash format: ${format}`); + return _stringFormat(ZodCustomStringFormat, format, regex, params); +} +var ZodNumber2 = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => { + $ZodNumber.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params); + inst.gt = (value, params) => inst.check(_gt(value, params)); + inst.gte = (value, params) => inst.check(_gte(value, params)); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.lt = (value, params) => inst.check(_lt(value, params)); + inst.lte = (value, params) => inst.check(_lte(value, params)); + inst.max = (value, params) => inst.check(_lte(value, params)); + inst.int = (params) => inst.check(int(params)); + inst.safe = (params) => inst.check(int(params)); + inst.positive = (params) => inst.check(_gt(0, params)); + inst.nonnegative = (params) => inst.check(_gte(0, params)); + inst.negative = (params) => inst.check(_lt(0, params)); + inst.nonpositive = (params) => inst.check(_lte(0, params)); + inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params)); + inst.step = (value, params) => inst.check(_multipleOf(value, params)); + inst.finite = () => inst; + const bag = inst._zod.bag; + inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null; + inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null; + inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5); + inst.isFinite = true; + inst.format = bag.format ?? null; +}); +function number2(params) { + return _number(ZodNumber2, params); +} +var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => { + $ZodNumberFormat.init(inst, def); + ZodNumber2.init(inst, def); +}); +function int(params) { + return _int(ZodNumberFormat, params); +} +function float32(params) { + return _float32(ZodNumberFormat, params); +} +function float64(params) { + return _float64(ZodNumberFormat, params); +} +function int32(params) { + return _int32(ZodNumberFormat, params); +} +function uint32(params) { + return _uint32(ZodNumberFormat, params); +} +var ZodBoolean2 = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => { + $ZodBoolean.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params); +}); +function boolean2(params) { + return _boolean(ZodBoolean2, params); +} +var ZodBigInt2 = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => { + $ZodBigInt.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params); + inst.gte = (value, params) => inst.check(_gte(value, params)); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.gt = (value, params) => inst.check(_gt(value, params)); + inst.gte = (value, params) => inst.check(_gte(value, params)); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.lt = (value, params) => inst.check(_lt(value, params)); + inst.lte = (value, params) => inst.check(_lte(value, params)); + inst.max = (value, params) => inst.check(_lte(value, params)); + inst.positive = (params) => inst.check(_gt(BigInt(0), params)); + inst.negative = (params) => inst.check(_lt(BigInt(0), params)); + inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params)); + inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params)); + inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params)); + const bag = inst._zod.bag; + inst.minValue = bag.minimum ?? null; + inst.maxValue = bag.maximum ?? null; + inst.format = bag.format ?? null; +}); +function bigint2(params) { + return _bigint(ZodBigInt2, params); +} +var ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => { + $ZodBigIntFormat.init(inst, def); + ZodBigInt2.init(inst, def); +}); +function int64(params) { + return _int64(ZodBigIntFormat, params); +} +function uint64(params) { + return _uint64(ZodBigIntFormat, params); +} +var ZodSymbol2 = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => { + $ZodSymbol.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params); +}); +function symbol(params) { + return _symbol(ZodSymbol2, params); +} +var ZodUndefined2 = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => { + $ZodUndefined.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params); +}); +function _undefined3(params) { + return _undefined2(ZodUndefined2, params); +} +var ZodNull2 = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => { + $ZodNull.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params); +}); +function _null3(params) { + return _null2(ZodNull2, params); +} +var ZodAny2 = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => { + $ZodAny.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params); +}); +function any() { + return _any(ZodAny2); +} +var ZodUnknown2 = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => { + $ZodUnknown.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params); +}); +function unknown() { + return _unknown(ZodUnknown2); +} +var ZodNever2 = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => { + $ZodNever.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params); +}); +function never(params) { + return _never(ZodNever2, params); +} +var ZodVoid2 = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => { + $ZodVoid.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params); +}); +function _void2(params) { + return _void(ZodVoid2, params); +} +var ZodDate2 = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => { + $ZodDate.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params); + inst.min = (value, params) => inst.check(_gte(value, params)); + inst.max = (value, params) => inst.check(_lte(value, params)); + const c = inst._zod.bag; + inst.minDate = c.minimum ? new Date(c.minimum) : null; + inst.maxDate = c.maximum ? new Date(c.maximum) : null; +}); +function date3(params) { + return _date(ZodDate2, params); +} +var ZodArray2 = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => { + $ZodArray.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params); + inst.element = def.element; + inst.min = (minLength, params) => inst.check(_minLength(minLength, params)); + inst.nonempty = (params) => inst.check(_minLength(1, params)); + inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params)); + inst.length = (len, params) => inst.check(_length(len, params)); + inst.unwrap = () => inst.element; +}); +function array(element, params) { + return _array(ZodArray2, element, params); +} +function keyof(schema) { + const shape = schema._zod.def.shape; + return _enum(Object.keys(shape)); +} +var ZodObject2 = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => { + $ZodObjectJIT.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params); + util_exports.defineLazy(inst, "shape", () => { + return def.shape; + }); + inst.keyof = () => _enum(Object.keys(inst._zod.def.shape)); + inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall }); + inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); + inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() }); + inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() }); + inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 }); + inst.extend = (incoming) => { + return util_exports.extend(inst, incoming); + }; + inst.safeExtend = (incoming) => { + return util_exports.safeExtend(inst, incoming); + }; + inst.merge = (other) => util_exports.merge(inst, other); + inst.pick = (mask) => util_exports.pick(inst, mask); + inst.omit = (mask) => util_exports.omit(inst, mask); + inst.partial = (...args) => util_exports.partial(ZodOptional2, inst, args[0]); + inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]); +}); +function object2(shape, params) { + const def = { + type: "object", + shape: shape ?? {}, + ...util_exports.normalizeParams(params) + }; + return new ZodObject2(def); +} +function strictObject(shape, params) { + return new ZodObject2({ + type: "object", + shape, + catchall: never(), + ...util_exports.normalizeParams(params) + }); +} +function looseObject(shape, params) { + return new ZodObject2({ + type: "object", + shape, + catchall: unknown(), + ...util_exports.normalizeParams(params) + }); +} +var ZodUnion2 = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => { + $ZodUnion.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params); + inst.options = def.options; +}); +function union(options, params) { + return new ZodUnion2({ + type: "union", + options, + ...util_exports.normalizeParams(params) + }); +} +var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => { + ZodUnion2.init(inst, def); + $ZodXor.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params); + inst.options = def.options; +}); +function xor(options, params) { + return new ZodXor({ + type: "union", + options, + inclusive: false, + ...util_exports.normalizeParams(params) + }); +} +var ZodDiscriminatedUnion2 = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => { + ZodUnion2.init(inst, def); + $ZodDiscriminatedUnion.init(inst, def); +}); +function discriminatedUnion(discriminator, options, params) { + return new ZodDiscriminatedUnion2({ + type: "union", + options, + discriminator, + ...util_exports.normalizeParams(params) + }); +} +var ZodIntersection2 = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => { + $ZodIntersection.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params); +}); +function intersection(left, right) { + return new ZodIntersection2({ + type: "intersection", + left, + right + }); +} +var ZodTuple2 = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => { + $ZodTuple.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params); + inst.rest = (rest) => inst.clone({ + ...inst._zod.def, + rest + }); +}); +function tuple(items, _paramsOrRest, _params) { + const hasRest = _paramsOrRest instanceof $ZodType; + const params = hasRest ? _params : _paramsOrRest; + const rest = hasRest ? _paramsOrRest : null; + return new ZodTuple2({ + type: "tuple", + items, + rest, + ...util_exports.normalizeParams(params) + }); +} +var ZodRecord2 = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => { + $ZodRecord.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params); + inst.keyType = def.keyType; + inst.valueType = def.valueType; +}); +function record(keyType, valueType, params) { + return new ZodRecord2({ + type: "record", + keyType, + valueType, + ...util_exports.normalizeParams(params) + }); +} +function partialRecord(keyType, valueType, params) { + const k = clone(keyType); + k._zod.values = void 0; + return new ZodRecord2({ + type: "record", + keyType: k, + valueType, + ...util_exports.normalizeParams(params) + }); +} +function looseRecord(keyType, valueType, params) { + return new ZodRecord2({ + type: "record", + keyType, + valueType, + mode: "loose", + ...util_exports.normalizeParams(params) + }); +} +var ZodMap2 = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => { + $ZodMap.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params); + inst.keyType = def.keyType; + inst.valueType = def.valueType; + inst.min = (...args) => inst.check(_minSize(...args)); + inst.nonempty = (params) => inst.check(_minSize(1, params)); + inst.max = (...args) => inst.check(_maxSize(...args)); + inst.size = (...args) => inst.check(_size(...args)); +}); +function map(keyType, valueType, params) { + return new ZodMap2({ + type: "map", + keyType, + valueType, + ...util_exports.normalizeParams(params) + }); +} +var ZodSet2 = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => { + $ZodSet.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params); + inst.min = (...args) => inst.check(_minSize(...args)); + inst.nonempty = (params) => inst.check(_minSize(1, params)); + inst.max = (...args) => inst.check(_maxSize(...args)); + inst.size = (...args) => inst.check(_size(...args)); +}); +function set(valueType, params) { + return new ZodSet2({ + type: "set", + valueType, + ...util_exports.normalizeParams(params) + }); +} +var ZodEnum2 = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => { + $ZodEnum.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params); + inst.enum = def.entries; + inst.options = Object.values(def.entries); + const keys = new Set(Object.keys(def.entries)); + inst.extract = (values, params) => { + const newEntries = {}; + for (const value of values) { + if (keys.has(value)) { + newEntries[value] = def.entries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum2({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; + inst.exclude = (values, params) => { + const newEntries = { ...def.entries }; + for (const value of values) { + if (keys.has(value)) { + delete newEntries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum2({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; +}); +function _enum(values, params) { + const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values; + return new ZodEnum2({ + type: "enum", + entries, + ...util_exports.normalizeParams(params) + }); +} +function nativeEnum(entries, params) { + return new ZodEnum2({ + type: "enum", + entries, + ...util_exports.normalizeParams(params) + }); +} +var ZodLiteral2 = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => { + $ZodLiteral.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params); + inst.values = new Set(def.values); + Object.defineProperty(inst, "value", { + get() { + if (def.values.length > 1) { + throw new Error("This schema contains multiple valid literal values. Use `.values` instead."); + } + return def.values[0]; + } + }); +}); +function literal(value, params) { + return new ZodLiteral2({ + type: "literal", + values: Array.isArray(value) ? value : [value], + ...util_exports.normalizeParams(params) + }); +} +var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => { + $ZodFile.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params); + inst.min = (size, params) => inst.check(_minSize(size, params)); + inst.max = (size, params) => inst.check(_maxSize(size, params)); + inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params)); +}); +function file(params) { + return _file(ZodFile, params); +} +var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => { + $ZodTransform.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params); + inst._zod.parse = (payload, _ctx) => { + if (_ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + payload.addIssue = (issue2) => { + if (typeof issue2 === "string") { + payload.issues.push(util_exports.issue(issue2, payload.value, def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = inst); + payload.issues.push(util_exports.issue(_issue)); + } + }; + const output = def.transform(payload.value, payload); + if (output instanceof Promise) { + return output.then((output2) => { + payload.value = output2; + return payload; + }); + } + payload.value = output; + return payload; + }; +}); +function transform(fn) { + return new ZodTransform({ + type: "transform", + transform: fn + }); +} +var ZodOptional2 = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => { + $ZodOptional.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function optional(innerType) { + return new ZodOptional2({ + type: "optional", + innerType + }); +} +var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => { + $ZodExactOptional.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function exactOptional(innerType) { + return new ZodExactOptional({ + type: "optional", + innerType + }); +} +var ZodNullable2 = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => { + $ZodNullable.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nullable(innerType) { + return new ZodNullable2({ + type: "nullable", + innerType + }); +} +function nullish2(innerType) { + return optional(nullable(innerType)); +} +var ZodDefault2 = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => { + $ZodDefault.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeDefault = inst.unwrap; +}); +function _default(innerType, defaultValue) { + return new ZodDefault2({ + type: "default", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => { + $ZodPrefault.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function prefault(innerType, defaultValue) { + return new ZodPrefault({ + type: "prefault", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => { + $ZodNonOptional.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nonoptional(innerType, params) { + return new ZodNonOptional({ + type: "nonoptional", + innerType, + ...util_exports.normalizeParams(params) + }); +} +var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => { + $ZodSuccess.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function success(innerType) { + return new ZodSuccess({ + type: "success", + innerType + }); +} +var ZodCatch2 = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => { + $ZodCatch.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeCatch = inst.unwrap; +}); +function _catch(innerType, catchValue) { + return new ZodCatch2({ + type: "catch", + innerType, + catchValue: typeof catchValue === "function" ? catchValue : () => catchValue + }); +} +var ZodNaN2 = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => { + $ZodNaN.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params); +}); +function nan(params) { + return _nan(ZodNaN2, params); +} +var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => { + $ZodPipe.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params); + inst.in = def.in; + inst.out = def.out; +}); +function pipe(in_, out) { + return new ZodPipe({ + type: "pipe", + in: in_, + out + // ...util.normalizeParams(params), + }); +} +var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => { + ZodPipe.init(inst, def); + $ZodCodec.init(inst, def); +}); +function codec(in_, out, params) { + return new ZodCodec({ + type: "pipe", + in: in_, + out, + transform: params.decode, + reverseTransform: params.encode + }); +} +var ZodReadonly2 = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => { + $ZodReadonly.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function readonly(innerType) { + return new ZodReadonly2({ + type: "readonly", + innerType + }); +} +var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => { + $ZodTemplateLiteral.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params); +}); +function templateLiteral(parts, params) { + return new ZodTemplateLiteral({ + type: "template_literal", + parts, + ...util_exports.normalizeParams(params) + }); +} +var ZodLazy2 = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => { + $ZodLazy.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.getter(); +}); +function lazy(getter) { + return new ZodLazy2({ + type: "lazy", + getter + }); +} +var ZodPromise2 = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => { + $ZodPromise.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function promise(innerType) { + return new ZodPromise2({ + type: "promise", + innerType + }); +} +var ZodFunction2 = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => { + $ZodFunction.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params); +}); +function _function(params) { + return new ZodFunction2({ + type: "function", + input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()), + output: params?.output ?? unknown() + }); +} +var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => { + $ZodCustom.init(inst, def); + ZodType2.init(inst, def); + inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params); +}); +function check(fn) { + const ch = new $ZodCheck({ + check: "custom" + // ...util.normalizeParams(params), + }); + ch._zod.check = fn; + return ch; +} +function custom(fn, _params) { + return _custom(ZodCustom, fn ?? (() => true), _params); +} +function refine(fn, _params = {}) { + return _refine(ZodCustom, fn, _params); +} +function superRefine(fn) { + return _superRefine(fn); +} +var describe2 = describe; +var meta2 = meta; +function _instanceof(cls, params = {}) { + const inst = new ZodCustom({ + type: "custom", + check: "custom", + fn: (data) => data instanceof cls, + abort: true, + ...util_exports.normalizeParams(params) + }); + inst._zod.bag.Class = cls; + inst._zod.check = (payload) => { + if (!(payload.value instanceof cls)) { + payload.issues.push({ + code: "invalid_type", + expected: cls.name, + input: payload.value, + inst, + path: [...inst._zod.def.path ?? []] + }); + } + }; + return inst; +} +var stringbool = (...args) => _stringbool({ + Codec: ZodCodec, + Boolean: ZodBoolean2, + String: ZodString2 +}, ...args); +function json(params) { + const jsonSchema = lazy(() => { + return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]); + }); + return jsonSchema; +} +function preprocess(fn, schema) { + return pipe(transform(fn), schema); +} + +// node_modules/zod/v4/classic/compat.js +var ZodFirstPartyTypeKind2; +/* @__PURE__ */ (function(ZodFirstPartyTypeKind3) { +})(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {})); + +// node_modules/zod/v4/classic/from-json-schema.js +var z = { + ...schemas_exports3, + ...checks_exports2, + iso: iso_exports2 +}; + +// node_modules/zod/v4/classic/external.js +config(en_default2()); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/types.js +var LATEST_PROTOCOL_VERSION = "2025-11-25"; +var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"]; +var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task"; +var JSONRPC_VERSION = "2.0"; +var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function")); +var ProgressTokenSchema = union([string2(), number2().int()]); +var CursorSchema = string2(); +var TaskCreationParamsSchema = looseObject({ + /** + * Time in milliseconds to keep task results available after completion. + * If null, the task has unlimited lifetime until manually cleaned up. + */ + ttl: union([number2(), _null3()]).optional(), + /** + * Time in milliseconds to wait between task status requests. + */ + pollInterval: number2().optional() +}); +var TaskMetadataSchema = object2({ + ttl: number2().optional() +}); +var RelatedTaskMetadataSchema = object2({ + taskId: string2() +}); +var RequestMetaSchema = looseObject({ + /** + * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications. + */ + progressToken: ProgressTokenSchema.optional(), + /** + * If specified, this request is related to the provided task. + */ + [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional() +}); +var BaseRequestParamsSchema = object2({ + /** + * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage. + */ + _meta: RequestMetaSchema.optional() +}); +var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * If specified, the caller is requesting task-augmented execution for this request. + * The request will return a CreateTaskResult immediately, and the actual result can be + * retrieved later via tasks/result. + * + * Task augmentation is subject to capability negotiation - receivers MUST declare support + * for task augmentation of specific request types in their capabilities. + */ + task: TaskMetadataSchema.optional() +}); +var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success; +var RequestSchema = object2({ + method: string2(), + params: BaseRequestParamsSchema.loose().optional() +}); +var NotificationsParamsSchema = object2({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: RequestMetaSchema.optional() +}); +var NotificationSchema = object2({ + method: string2(), + params: NotificationsParamsSchema.loose().optional() +}); +var ResultSchema = looseObject({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: RequestMetaSchema.optional() +}); +var RequestIdSchema = union([string2(), number2().int()]); +var JSONRPCRequestSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + id: RequestIdSchema, + ...RequestSchema.shape +}).strict(); +var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success; +var JSONRPCNotificationSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + ...NotificationSchema.shape +}).strict(); +var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success; +var JSONRPCResultResponseSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + id: RequestIdSchema, + result: ResultSchema +}).strict(); +var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success; +var ErrorCode; +(function(ErrorCode2) { + ErrorCode2[ErrorCode2["ConnectionClosed"] = -32e3] = "ConnectionClosed"; + ErrorCode2[ErrorCode2["RequestTimeout"] = -32001] = "RequestTimeout"; + ErrorCode2[ErrorCode2["ParseError"] = -32700] = "ParseError"; + ErrorCode2[ErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest"; + ErrorCode2[ErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound"; + ErrorCode2[ErrorCode2["InvalidParams"] = -32602] = "InvalidParams"; + ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError"; + ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired"; +})(ErrorCode || (ErrorCode = {})); +var JSONRPCErrorResponseSchema = object2({ + jsonrpc: literal(JSONRPC_VERSION), + id: RequestIdSchema.optional(), + error: object2({ + /** + * The error type that occurred. + */ + code: number2().int(), + /** + * A short description of the error. The message SHOULD be limited to a concise single sentence. + */ + message: string2(), + /** + * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.). + */ + data: unknown().optional() + }) +}).strict(); +var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success; +var JSONRPCMessageSchema = union([ + JSONRPCRequestSchema, + JSONRPCNotificationSchema, + JSONRPCResultResponseSchema, + JSONRPCErrorResponseSchema +]); +var JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]); +var EmptyResultSchema = ResultSchema.strict(); +var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The ID of the request to cancel. + * + * This MUST correspond to the ID of a request previously issued in the same direction. + */ + requestId: RequestIdSchema.optional(), + /** + * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user. + */ + reason: string2().optional() +}); +var CancelledNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/cancelled"), + params: CancelledNotificationParamsSchema +}); +var IconSchema = object2({ + /** + * URL or data URI for the icon. + */ + src: string2(), + /** + * Optional MIME type for the icon. + */ + mimeType: string2().optional(), + /** + * Optional array of strings that specify sizes at which the icon can be used. + * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG. + * + * If not provided, the client should assume that the icon can be used at any size. + */ + sizes: array(string2()).optional(), + /** + * Optional specifier for the theme this icon is designed for. `light` indicates + * the icon is designed to be used with a light background, and `dark` indicates + * the icon is designed to be used with a dark background. + * + * If not provided, the client should assume the icon can be used with any theme. + */ + theme: _enum(["light", "dark"]).optional() +}); +var IconsSchema = object2({ + /** + * Optional set of sized icons that the client can display in a user interface. + * + * Clients that support rendering icons MUST support at least the following MIME types: + * - `image/png` - PNG images (safe, universal compatibility) + * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility) + * + * Clients that support rendering icons SHOULD also support: + * - `image/svg+xml` - SVG images (scalable but requires security precautions) + * - `image/webp` - WebP images (modern, efficient format) + */ + icons: array(IconSchema).optional() +}); +var BaseMetadataSchema = object2({ + /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */ + name: string2(), + /** + * Intended for UI and end-user contexts — optimized to be human-readable and easily understood, + * even by those unfamiliar with domain-specific terminology. + * + * If not provided, the name should be used for display (except for Tool, + * where `annotations.title` should be given precedence over using `name`, + * if present). + */ + title: string2().optional() +}); +var ImplementationSchema = BaseMetadataSchema.extend({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + version: string2(), + /** + * An optional URL of the website for this implementation. + */ + websiteUrl: string2().optional(), + /** + * An optional human-readable description of what this implementation does. + * + * This can be used by clients or servers to provide context about their purpose + * and capabilities. For example, a server might describe the types of resources + * or tools it provides, while a client might describe its intended use case. + */ + description: string2().optional() +}); +var FormElicitationCapabilitySchema = intersection(object2({ + applyDefaults: boolean2().optional() +}), record(string2(), unknown())); +var ElicitationCapabilitySchema = preprocess((value) => { + if (value && typeof value === "object" && !Array.isArray(value)) { + if (Object.keys(value).length === 0) { + return { form: {} }; + } + } + return value; +}, intersection(object2({ + form: FormElicitationCapabilitySchema.optional(), + url: AssertObjectSchema.optional() +}), record(string2(), unknown()).optional())); +var ClientTasksCapabilitySchema = looseObject({ + /** + * Present if the client supports listing tasks. + */ + list: AssertObjectSchema.optional(), + /** + * Present if the client supports cancelling tasks. + */ + cancel: AssertObjectSchema.optional(), + /** + * Capabilities for task creation on specific request types. + */ + requests: looseObject({ + /** + * Task support for sampling requests. + */ + sampling: looseObject({ + createMessage: AssertObjectSchema.optional() + }).optional(), + /** + * Task support for elicitation requests. + */ + elicitation: looseObject({ + create: AssertObjectSchema.optional() + }).optional() + }).optional() +}); +var ServerTasksCapabilitySchema = looseObject({ + /** + * Present if the server supports listing tasks. + */ + list: AssertObjectSchema.optional(), + /** + * Present if the server supports cancelling tasks. + */ + cancel: AssertObjectSchema.optional(), + /** + * Capabilities for task creation on specific request types. + */ + requests: looseObject({ + /** + * Task support for tool requests. + */ + tools: looseObject({ + call: AssertObjectSchema.optional() + }).optional() + }).optional() +}); +var ClientCapabilitiesSchema = object2({ + /** + * Experimental, non-standard capabilities that the client supports. + */ + experimental: record(string2(), AssertObjectSchema).optional(), + /** + * Present if the client supports sampling from an LLM. + */ + sampling: object2({ + /** + * Present if the client supports context inclusion via includeContext parameter. + * If not declared, servers SHOULD only use `includeContext: "none"` (or omit it). + */ + context: AssertObjectSchema.optional(), + /** + * Present if the client supports tool use via tools and toolChoice parameters. + */ + tools: AssertObjectSchema.optional() + }).optional(), + /** + * Present if the client supports eliciting user input. + */ + elicitation: ElicitationCapabilitySchema.optional(), + /** + * Present if the client supports listing roots. + */ + roots: object2({ + /** + * Whether the client supports issuing notifications for changes to the roots list. + */ + listChanged: boolean2().optional() + }).optional(), + /** + * Present if the client supports task creation. + */ + tasks: ClientTasksCapabilitySchema.optional() +}); +var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well. + */ + protocolVersion: string2(), + capabilities: ClientCapabilitiesSchema, + clientInfo: ImplementationSchema +}); +var InitializeRequestSchema = RequestSchema.extend({ + method: literal("initialize"), + params: InitializeRequestParamsSchema +}); +var ServerCapabilitiesSchema = object2({ + /** + * Experimental, non-standard capabilities that the server supports. + */ + experimental: record(string2(), AssertObjectSchema).optional(), + /** + * Present if the server supports sending log messages to the client. + */ + logging: AssertObjectSchema.optional(), + /** + * Present if the server supports sending completions to the client. + */ + completions: AssertObjectSchema.optional(), + /** + * Present if the server offers any prompt templates. + */ + prompts: object2({ + /** + * Whether this server supports issuing notifications for changes to the prompt list. + */ + listChanged: boolean2().optional() + }).optional(), + /** + * Present if the server offers any resources to read. + */ + resources: object2({ + /** + * Whether this server supports clients subscribing to resource updates. + */ + subscribe: boolean2().optional(), + /** + * Whether this server supports issuing notifications for changes to the resource list. + */ + listChanged: boolean2().optional() + }).optional(), + /** + * Present if the server offers any tools to call. + */ + tools: object2({ + /** + * Whether this server supports issuing notifications for changes to the tool list. + */ + listChanged: boolean2().optional() + }).optional(), + /** + * Present if the server supports task creation. + */ + tasks: ServerTasksCapabilitySchema.optional() +}); +var InitializeResultSchema = ResultSchema.extend({ + /** + * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect. + */ + protocolVersion: string2(), + capabilities: ServerCapabilitiesSchema, + serverInfo: ImplementationSchema, + /** + * Instructions describing how to use the server and its features. + * + * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt. + */ + instructions: string2().optional() +}); +var InitializedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/initialized"), + params: NotificationsParamsSchema.optional() +}); +var PingRequestSchema = RequestSchema.extend({ + method: literal("ping"), + params: BaseRequestParamsSchema.optional() +}); +var ProgressSchema = object2({ + /** + * The progress thus far. This should increase every time progress is made, even if the total is unknown. + */ + progress: number2(), + /** + * Total number of items to process (or total progress required), if known. + */ + total: optional(number2()), + /** + * An optional message describing the current progress. + */ + message: optional(string2()) +}); +var ProgressNotificationParamsSchema = object2({ + ...NotificationsParamsSchema.shape, + ...ProgressSchema.shape, + /** + * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding. + */ + progressToken: ProgressTokenSchema +}); +var ProgressNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/progress"), + params: ProgressNotificationParamsSchema +}); +var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * An opaque token representing the current pagination position. + * If provided, the server should return results starting after this cursor. + */ + cursor: CursorSchema.optional() +}); +var PaginatedRequestSchema = RequestSchema.extend({ + params: PaginatedRequestParamsSchema.optional() +}); +var PaginatedResultSchema = ResultSchema.extend({ + /** + * An opaque token representing the pagination position after the last returned result. + * If present, there may be more results available. + */ + nextCursor: CursorSchema.optional() +}); +var TaskStatusSchema = _enum(["working", "input_required", "completed", "failed", "cancelled"]); +var TaskSchema = object2({ + taskId: string2(), + status: TaskStatusSchema, + /** + * Time in milliseconds to keep task results available after completion. + * If null, the task has unlimited lifetime until manually cleaned up. + */ + ttl: union([number2(), _null3()]), + /** + * ISO 8601 timestamp when the task was created. + */ + createdAt: string2(), + /** + * ISO 8601 timestamp when the task was last updated. + */ + lastUpdatedAt: string2(), + pollInterval: optional(number2()), + /** + * Optional diagnostic message for failed tasks or other status information. + */ + statusMessage: optional(string2()) +}); +var CreateTaskResultSchema = ResultSchema.extend({ + task: TaskSchema +}); +var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema); +var TaskStatusNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/tasks/status"), + params: TaskStatusNotificationParamsSchema +}); +var GetTaskRequestSchema = RequestSchema.extend({ + method: literal("tasks/get"), + params: BaseRequestParamsSchema.extend({ + taskId: string2() + }) +}); +var GetTaskResultSchema = ResultSchema.merge(TaskSchema); +var GetTaskPayloadRequestSchema = RequestSchema.extend({ + method: literal("tasks/result"), + params: BaseRequestParamsSchema.extend({ + taskId: string2() + }) +}); +var GetTaskPayloadResultSchema = ResultSchema.loose(); +var ListTasksRequestSchema = PaginatedRequestSchema.extend({ + method: literal("tasks/list") +}); +var ListTasksResultSchema = PaginatedResultSchema.extend({ + tasks: array(TaskSchema) +}); +var CancelTaskRequestSchema = RequestSchema.extend({ + method: literal("tasks/cancel"), + params: BaseRequestParamsSchema.extend({ + taskId: string2() + }) +}); +var CancelTaskResultSchema = ResultSchema.merge(TaskSchema); +var ResourceContentsSchema = object2({ + /** + * The URI of this resource. + */ + uri: string2(), + /** + * The MIME type of this resource, if known. + */ + mimeType: optional(string2()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var TextResourceContentsSchema = ResourceContentsSchema.extend({ + /** + * The text of the item. This must only be set if the item can actually be represented as text (not binary data). + */ + text: string2() +}); +var Base64Schema = string2().refine((val) => { + try { + atob(val); + return true; + } catch { + return false; + } +}, { message: "Invalid Base64 string" }); +var BlobResourceContentsSchema = ResourceContentsSchema.extend({ + /** + * A base64-encoded string representing the binary data of the item. + */ + blob: Base64Schema +}); +var RoleSchema = _enum(["user", "assistant"]); +var AnnotationsSchema = object2({ + /** + * Intended audience(s) for the resource. + */ + audience: array(RoleSchema).optional(), + /** + * Importance hint for the resource, from 0 (least) to 1 (most). + */ + priority: number2().min(0).max(1).optional(), + /** + * ISO 8601 timestamp for the most recent modification. + */ + lastModified: iso_exports2.datetime({ offset: true }).optional() +}); +var ResourceSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * The URI of this resource. + */ + uri: string2(), + /** + * A description of what this resource represents. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: optional(string2()), + /** + * The MIME type of this resource, if known. + */ + mimeType: optional(string2()), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: optional(looseObject({})) +}); +var ResourceTemplateSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * A URI template (according to RFC 6570) that can be used to construct resource URIs. + */ + uriTemplate: string2(), + /** + * A description of what this template is for. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: optional(string2()), + /** + * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type. + */ + mimeType: optional(string2()), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: optional(looseObject({})) +}); +var ListResourcesRequestSchema = PaginatedRequestSchema.extend({ + method: literal("resources/list") +}); +var ListResourcesResultSchema = PaginatedResultSchema.extend({ + resources: array(ResourceSchema) +}); +var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({ + method: literal("resources/templates/list") +}); +var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({ + resourceTemplates: array(ResourceTemplateSchema) +}); +var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it. + * + * @format uri + */ + uri: string2() +}); +var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema; +var ReadResourceRequestSchema = RequestSchema.extend({ + method: literal("resources/read"), + params: ReadResourceRequestParamsSchema +}); +var ReadResourceResultSchema = ResultSchema.extend({ + contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema])) +}); +var ResourceListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/resources/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var SubscribeRequestParamsSchema = ResourceRequestParamsSchema; +var SubscribeRequestSchema = RequestSchema.extend({ + method: literal("resources/subscribe"), + params: SubscribeRequestParamsSchema +}); +var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema; +var UnsubscribeRequestSchema = RequestSchema.extend({ + method: literal("resources/unsubscribe"), + params: UnsubscribeRequestParamsSchema +}); +var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to. + */ + uri: string2() +}); +var ResourceUpdatedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/resources/updated"), + params: ResourceUpdatedNotificationParamsSchema +}); +var PromptArgumentSchema = object2({ + /** + * The name of the argument. + */ + name: string2(), + /** + * A human-readable description of the argument. + */ + description: optional(string2()), + /** + * Whether this argument must be provided. + */ + required: optional(boolean2()) +}); +var PromptSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * An optional description of what this prompt provides + */ + description: optional(string2()), + /** + * A list of arguments to use for templating the prompt. + */ + arguments: optional(array(PromptArgumentSchema)), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: optional(looseObject({})) +}); +var ListPromptsRequestSchema = PaginatedRequestSchema.extend({ + method: literal("prompts/list") +}); +var ListPromptsResultSchema = PaginatedResultSchema.extend({ + prompts: array(PromptSchema) +}); +var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The name of the prompt or prompt template. + */ + name: string2(), + /** + * Arguments to use for templating the prompt. + */ + arguments: record(string2(), string2()).optional() +}); +var GetPromptRequestSchema = RequestSchema.extend({ + method: literal("prompts/get"), + params: GetPromptRequestParamsSchema +}); +var TextContentSchema = object2({ + type: literal("text"), + /** + * The text content of the message. + */ + text: string2(), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var ImageContentSchema = object2({ + type: literal("image"), + /** + * The base64-encoded image data. + */ + data: Base64Schema, + /** + * The MIME type of the image. Different providers may support different image types. + */ + mimeType: string2(), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var AudioContentSchema = object2({ + type: literal("audio"), + /** + * The base64-encoded audio data. + */ + data: Base64Schema, + /** + * The MIME type of the audio. Different providers may support different audio types. + */ + mimeType: string2(), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var ToolUseContentSchema = object2({ + type: literal("tool_use"), + /** + * The name of the tool to invoke. + * Must match a tool name from the request's tools array. + */ + name: string2(), + /** + * Unique identifier for this tool call. + * Used to correlate with ToolResultContent in subsequent messages. + */ + id: string2(), + /** + * Arguments to pass to the tool. + * Must conform to the tool's inputSchema. + */ + input: record(string2(), unknown()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var EmbeddedResourceSchema = object2({ + type: literal("resource"), + resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]), + /** + * Optional annotations for the client. + */ + annotations: AnnotationsSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var ResourceLinkSchema = ResourceSchema.extend({ + type: literal("resource_link") +}); +var ContentBlockSchema = union([ + TextContentSchema, + ImageContentSchema, + AudioContentSchema, + ResourceLinkSchema, + EmbeddedResourceSchema +]); +var PromptMessageSchema = object2({ + role: RoleSchema, + content: ContentBlockSchema +}); +var GetPromptResultSchema = ResultSchema.extend({ + /** + * An optional description for the prompt. + */ + description: string2().optional(), + messages: array(PromptMessageSchema) +}); +var PromptListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/prompts/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var ToolAnnotationsSchema = object2({ + /** + * A human-readable title for the tool. + */ + title: string2().optional(), + /** + * If true, the tool does not modify its environment. + * + * Default: false + */ + readOnlyHint: boolean2().optional(), + /** + * If true, the tool may perform destructive updates to its environment. + * If false, the tool performs only additive updates. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: true + */ + destructiveHint: boolean2().optional(), + /** + * If true, calling the tool repeatedly with the same arguments + * will have no additional effect on the its environment. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: false + */ + idempotentHint: boolean2().optional(), + /** + * If true, this tool may interact with an "open world" of external + * entities. If false, the tool's domain of interaction is closed. + * For example, the world of a web search tool is open, whereas that + * of a memory tool is not. + * + * Default: true + */ + openWorldHint: boolean2().optional() +}); +var ToolExecutionSchema = object2({ + /** + * Indicates the tool's preference for task-augmented execution. + * - "required": Clients MUST invoke the tool as a task + * - "optional": Clients MAY invoke the tool as a task or normal request + * - "forbidden": Clients MUST NOT attempt to invoke the tool as a task + * + * If not present, defaults to "forbidden". + */ + taskSupport: _enum(["required", "optional", "forbidden"]).optional() +}); +var ToolSchema = object2({ + ...BaseMetadataSchema.shape, + ...IconsSchema.shape, + /** + * A human-readable description of the tool. + */ + description: string2().optional(), + /** + * A JSON Schema 2020-12 object defining the expected parameters for the tool. + * Must have type: 'object' at the root level per MCP spec. + */ + inputSchema: object2({ + type: literal("object"), + properties: record(string2(), AssertObjectSchema).optional(), + required: array(string2()).optional() + }).catchall(unknown()), + /** + * An optional JSON Schema 2020-12 object defining the structure of the tool's output + * returned in the structuredContent field of a CallToolResult. + * Must have type: 'object' at the root level per MCP spec. + */ + outputSchema: object2({ + type: literal("object"), + properties: record(string2(), AssertObjectSchema).optional(), + required: array(string2()).optional() + }).catchall(unknown()).optional(), + /** + * Optional additional tool information. + */ + annotations: ToolAnnotationsSchema.optional(), + /** + * Execution-related properties for this tool. + */ + execution: ToolExecutionSchema.optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var ListToolsRequestSchema = PaginatedRequestSchema.extend({ + method: literal("tools/list") +}); +var ListToolsResultSchema = PaginatedResultSchema.extend({ + tools: array(ToolSchema) +}); +var CallToolResultSchema = ResultSchema.extend({ + /** + * A list of content objects that represent the result of the tool call. + * + * If the Tool does not define an outputSchema, this field MUST be present in the result. + * For backwards compatibility, this field is always present, but it may be empty. + */ + content: array(ContentBlockSchema).default([]), + /** + * An object containing structured tool output. + * + * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema. + */ + structuredContent: record(string2(), unknown()).optional(), + /** + * Whether the tool call ended in an error. + * + * If not set, this is assumed to be false (the call was successful). + * + * Any errors that originate from the tool SHOULD be reported inside the result + * object, with `isError` set to true, _not_ as an MCP protocol-level error + * response. Otherwise, the LLM would not be able to see that an error occurred + * and self-correct. + * + * However, any errors in _finding_ the tool, an error indicating that the + * server does not support tool calls, or any other exceptional conditions, + * should be reported as an MCP error response. + */ + isError: boolean2().optional() +}); +var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({ + toolResult: unknown() +})); +var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + /** + * The name of the tool to call. + */ + name: string2(), + /** + * Arguments to pass to the tool. + */ + arguments: record(string2(), unknown()).optional() +}); +var CallToolRequestSchema = RequestSchema.extend({ + method: literal("tools/call"), + params: CallToolRequestParamsSchema +}); +var ToolListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/tools/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var ListChangedOptionsBaseSchema = object2({ + /** + * If true, the list will be refreshed automatically when a list changed notification is received. + * The callback will be called with the updated list. + * + * If false, the callback will be called with null items, allowing manual refresh. + * + * @default true + */ + autoRefresh: boolean2().default(true), + /** + * Debounce time in milliseconds for list changed notification processing. + * + * Multiple notifications received within this timeframe will only trigger one refresh. + * Set to 0 to disable debouncing. + * + * @default 300 + */ + debounceMs: number2().int().nonnegative().default(300) +}); +var LoggingLevelSchema = _enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]); +var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({ + /** + * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message. + */ + level: LoggingLevelSchema +}); +var SetLevelRequestSchema = RequestSchema.extend({ + method: literal("logging/setLevel"), + params: SetLevelRequestParamsSchema +}); +var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The severity of this log message. + */ + level: LoggingLevelSchema, + /** + * An optional name of the logger issuing this message. + */ + logger: string2().optional(), + /** + * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here. + */ + data: unknown() +}); +var LoggingMessageNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/message"), + params: LoggingMessageNotificationParamsSchema +}); +var ModelHintSchema = object2({ + /** + * A hint for a model name. + */ + name: string2().optional() +}); +var ModelPreferencesSchema = object2({ + /** + * Optional hints to use for model selection. + */ + hints: array(ModelHintSchema).optional(), + /** + * How much to prioritize cost when selecting a model. + */ + costPriority: number2().min(0).max(1).optional(), + /** + * How much to prioritize sampling speed (latency) when selecting a model. + */ + speedPriority: number2().min(0).max(1).optional(), + /** + * How much to prioritize intelligence and capabilities when selecting a model. + */ + intelligencePriority: number2().min(0).max(1).optional() +}); +var ToolChoiceSchema = object2({ + /** + * Controls when tools are used: + * - "auto": Model decides whether to use tools (default) + * - "required": Model MUST use at least one tool before completing + * - "none": Model MUST NOT use any tools + */ + mode: _enum(["auto", "required", "none"]).optional() +}); +var ToolResultContentSchema = object2({ + type: literal("tool_result"), + toolUseId: string2().describe("The unique identifier for the corresponding tool call."), + content: array(ContentBlockSchema).default([]), + structuredContent: object2({}).loose().optional(), + isError: boolean2().optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]); +var SamplingMessageContentBlockSchema = discriminatedUnion("type", [ + TextContentSchema, + ImageContentSchema, + AudioContentSchema, + ToolUseContentSchema, + ToolResultContentSchema +]); +var SamplingMessageSchema = object2({ + role: RoleSchema, + content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + messages: array(SamplingMessageSchema), + /** + * The server's preferences for which model to select. The client MAY modify or omit this request. + */ + modelPreferences: ModelPreferencesSchema.optional(), + /** + * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt. + */ + systemPrompt: string2().optional(), + /** + * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. + * The client MAY ignore this request. + * + * Default is "none". Values "thisServer" and "allServers" are soft-deprecated. Servers SHOULD only use these values if the client + * declares ClientCapabilities.sampling.context. These values may be removed in future spec releases. + */ + includeContext: _enum(["none", "thisServer", "allServers"]).optional(), + temperature: number2().optional(), + /** + * The requested maximum number of tokens to sample (to prevent runaway completions). + * + * The client MAY choose to sample fewer tokens than the requested maximum. + */ + maxTokens: number2().int(), + stopSequences: array(string2()).optional(), + /** + * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific. + */ + metadata: AssertObjectSchema.optional(), + /** + * Tools that the model may use during generation. + * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared. + */ + tools: array(ToolSchema).optional(), + /** + * Controls how the model uses tools. + * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared. + * Default is `{ mode: "auto" }`. + */ + toolChoice: ToolChoiceSchema.optional() +}); +var CreateMessageRequestSchema = RequestSchema.extend({ + method: literal("sampling/createMessage"), + params: CreateMessageRequestParamsSchema +}); +var CreateMessageResultSchema = ResultSchema.extend({ + /** + * The name of the model that generated the message. + */ + model: string2(), + /** + * The reason why sampling stopped, if known. + * + * Standard values: + * - "endTurn": Natural end of the assistant's turn + * - "stopSequence": A stop sequence was encountered + * - "maxTokens": Maximum token limit was reached + * + * This field is an open string to allow for provider-specific stop reasons. + */ + stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens"]).or(string2())), + role: RoleSchema, + /** + * Response content. Single content block (text, image, or audio). + */ + content: SamplingContentSchema +}); +var CreateMessageResultWithToolsSchema = ResultSchema.extend({ + /** + * The name of the model that generated the message. + */ + model: string2(), + /** + * The reason why sampling stopped, if known. + * + * Standard values: + * - "endTurn": Natural end of the assistant's turn + * - "stopSequence": A stop sequence was encountered + * - "maxTokens": Maximum token limit was reached + * - "toolUse": The model wants to use one or more tools + * + * This field is an open string to allow for provider-specific stop reasons. + */ + stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string2())), + role: RoleSchema, + /** + * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse". + */ + content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)]) +}); +var BooleanSchemaSchema = object2({ + type: literal("boolean"), + title: string2().optional(), + description: string2().optional(), + default: boolean2().optional() +}); +var StringSchemaSchema = object2({ + type: literal("string"), + title: string2().optional(), + description: string2().optional(), + minLength: number2().optional(), + maxLength: number2().optional(), + format: _enum(["email", "uri", "date", "date-time"]).optional(), + default: string2().optional() +}); +var NumberSchemaSchema = object2({ + type: _enum(["number", "integer"]), + title: string2().optional(), + description: string2().optional(), + minimum: number2().optional(), + maximum: number2().optional(), + default: number2().optional() +}); +var UntitledSingleSelectEnumSchemaSchema = object2({ + type: literal("string"), + title: string2().optional(), + description: string2().optional(), + enum: array(string2()), + default: string2().optional() +}); +var TitledSingleSelectEnumSchemaSchema = object2({ + type: literal("string"), + title: string2().optional(), + description: string2().optional(), + oneOf: array(object2({ + const: string2(), + title: string2() + })), + default: string2().optional() +}); +var LegacyTitledEnumSchemaSchema = object2({ + type: literal("string"), + title: string2().optional(), + description: string2().optional(), + enum: array(string2()), + enumNames: array(string2()).optional(), + default: string2().optional() +}); +var SingleSelectEnumSchemaSchema = union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]); +var UntitledMultiSelectEnumSchemaSchema = object2({ + type: literal("array"), + title: string2().optional(), + description: string2().optional(), + minItems: number2().optional(), + maxItems: number2().optional(), + items: object2({ + type: literal("string"), + enum: array(string2()) + }), + default: array(string2()).optional() +}); +var TitledMultiSelectEnumSchemaSchema = object2({ + type: literal("array"), + title: string2().optional(), + description: string2().optional(), + minItems: number2().optional(), + maxItems: number2().optional(), + items: object2({ + anyOf: array(object2({ + const: string2(), + title: string2() + })) + }), + default: array(string2()).optional() +}); +var MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]); +var EnumSchemaSchema = union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]); +var PrimitiveSchemaDefinitionSchema = union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]); +var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + /** + * The elicitation mode. + * + * Optional for backward compatibility. Clients MUST treat missing mode as "form". + */ + mode: literal("form").optional(), + /** + * The message to present to the user describing what information is being requested. + */ + message: string2(), + /** + * A restricted subset of JSON Schema. + * Only top-level properties are allowed, without nesting. + */ + requestedSchema: object2({ + type: literal("object"), + properties: record(string2(), PrimitiveSchemaDefinitionSchema), + required: array(string2()).optional() + }) +}); +var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({ + /** + * The elicitation mode. + */ + mode: literal("url"), + /** + * The message to present to the user explaining why the interaction is needed. + */ + message: string2(), + /** + * The ID of the elicitation, which must be unique within the context of the server. + * The client MUST treat this ID as an opaque value. + */ + elicitationId: string2(), + /** + * The URL that the user should navigate to. + */ + url: string2().url() +}); +var ElicitRequestParamsSchema = union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]); +var ElicitRequestSchema = RequestSchema.extend({ + method: literal("elicitation/create"), + params: ElicitRequestParamsSchema +}); +var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({ + /** + * The ID of the elicitation that completed. + */ + elicitationId: string2() +}); +var ElicitationCompleteNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/elicitation/complete"), + params: ElicitationCompleteNotificationParamsSchema +}); +var ElicitResultSchema = ResultSchema.extend({ + /** + * The user action in response to the elicitation. + * - "accept": User submitted the form/confirmed the action + * - "decline": User explicitly decline the action + * - "cancel": User dismissed without making an explicit choice + */ + action: _enum(["accept", "decline", "cancel"]), + /** + * The submitted form data, only present when action is "accept". + * Contains values matching the requested schema. + * Per MCP spec, content is "typically omitted" for decline/cancel actions. + * We normalize null to undefined for leniency while maintaining type compatibility. + */ + content: preprocess((val) => val === null ? void 0 : val, record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional()) +}); +var ResourceTemplateReferenceSchema = object2({ + type: literal("ref/resource"), + /** + * The URI or URI template of the resource. + */ + uri: string2() +}); +var PromptReferenceSchema = object2({ + type: literal("ref/prompt"), + /** + * The name of the prompt or prompt template + */ + name: string2() +}); +var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({ + ref: union([PromptReferenceSchema, ResourceTemplateReferenceSchema]), + /** + * The argument's information + */ + argument: object2({ + /** + * The name of the argument + */ + name: string2(), + /** + * The value of the argument to use for completion matching. + */ + value: string2() + }), + context: object2({ + /** + * Previously-resolved variables in a URI template or prompt. + */ + arguments: record(string2(), string2()).optional() + }).optional() +}); +var CompleteRequestSchema = RequestSchema.extend({ + method: literal("completion/complete"), + params: CompleteRequestParamsSchema +}); +var CompleteResultSchema = ResultSchema.extend({ + completion: looseObject({ + /** + * An array of completion values. Must not exceed 100 items. + */ + values: array(string2()).max(100), + /** + * The total number of completion options available. This can exceed the number of values actually sent in the response. + */ + total: optional(number2().int()), + /** + * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown. + */ + hasMore: optional(boolean2()) + }) +}); +var RootSchema = object2({ + /** + * The URI identifying the root. This *must* start with file:// for now. + */ + uri: string2().startsWith("file://"), + /** + * An optional name for the root. + */ + name: string2().optional(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: record(string2(), unknown()).optional() +}); +var ListRootsRequestSchema = RequestSchema.extend({ + method: literal("roots/list"), + params: BaseRequestParamsSchema.optional() +}); +var ListRootsResultSchema = ResultSchema.extend({ + roots: array(RootSchema) +}); +var RootsListChangedNotificationSchema = NotificationSchema.extend({ + method: literal("notifications/roots/list_changed"), + params: NotificationsParamsSchema.optional() +}); +var ClientRequestSchema = union([ + PingRequestSchema, + InitializeRequestSchema, + CompleteRequestSchema, + SetLevelRequestSchema, + GetPromptRequestSchema, + ListPromptsRequestSchema, + ListResourcesRequestSchema, + ListResourceTemplatesRequestSchema, + ReadResourceRequestSchema, + SubscribeRequestSchema, + UnsubscribeRequestSchema, + CallToolRequestSchema, + ListToolsRequestSchema, + GetTaskRequestSchema, + GetTaskPayloadRequestSchema, + ListTasksRequestSchema, + CancelTaskRequestSchema +]); +var ClientNotificationSchema = union([ + CancelledNotificationSchema, + ProgressNotificationSchema, + InitializedNotificationSchema, + RootsListChangedNotificationSchema, + TaskStatusNotificationSchema +]); +var ClientResultSchema = union([ + EmptyResultSchema, + CreateMessageResultSchema, + CreateMessageResultWithToolsSchema, + ElicitResultSchema, + ListRootsResultSchema, + GetTaskResultSchema, + ListTasksResultSchema, + CreateTaskResultSchema +]); +var ServerRequestSchema = union([ + PingRequestSchema, + CreateMessageRequestSchema, + ElicitRequestSchema, + ListRootsRequestSchema, + GetTaskRequestSchema, + GetTaskPayloadRequestSchema, + ListTasksRequestSchema, + CancelTaskRequestSchema +]); +var ServerNotificationSchema = union([ + CancelledNotificationSchema, + ProgressNotificationSchema, + LoggingMessageNotificationSchema, + ResourceUpdatedNotificationSchema, + ResourceListChangedNotificationSchema, + ToolListChangedNotificationSchema, + PromptListChangedNotificationSchema, + TaskStatusNotificationSchema, + ElicitationCompleteNotificationSchema +]); +var ServerResultSchema = union([ + EmptyResultSchema, + InitializeResultSchema, + CompleteResultSchema, + GetPromptResultSchema, + ListPromptsResultSchema, + ListResourcesResultSchema, + ListResourceTemplatesResultSchema, + ReadResourceResultSchema, + CallToolResultSchema, + ListToolsResultSchema, + GetTaskResultSchema, + ListTasksResultSchema, + CreateTaskResultSchema +]); +var McpError = class _McpError extends Error { + constructor(code, message, data) { + super(`MCP error ${code}: ${message}`); + this.code = code; + this.data = data; + this.name = "McpError"; + } + /** + * Factory method to create the appropriate error type based on the error code and data + */ + static fromError(code, message, data) { + if (code === ErrorCode.UrlElicitationRequired && data) { + const errorData = data; + if (errorData.elicitations) { + return new UrlElicitationRequiredError(errorData.elicitations, message); + } + } + return new _McpError(code, message, data); + } +}; +var UrlElicitationRequiredError = class extends McpError { + constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) { + super(ErrorCode.UrlElicitationRequired, message, { + elicitations + }); + } + get elicitations() { + return this.data?.elicitations ?? []; + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js +function isTerminal(status) { + return status === "completed" || status === "failed" || status === "cancelled"; +} + +// node_modules/zod-to-json-schema/dist/esm/Options.js +var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use"); + +// node_modules/zod-to-json-schema/dist/esm/parsers/string.js +var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js +function getMethodLiteral(schema) { + const shape = getObjectShape(schema); + const methodSchema = shape?.method; + if (!methodSchema) { + throw new Error("Schema is missing a method literal"); + } + const value = getLiteralValue(methodSchema); + if (typeof value !== "string") { + throw new Error("Schema method literal must be a string"); + } + return value; +} +function parseWithCompat(schema, data) { + const result = safeParse2(schema, data); + if (!result.success) { + throw result.error; + } + return result.data; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js +var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4; +var Protocol = class { + constructor(_options) { + this._options = _options; + this._requestMessageId = 0; + this._requestHandlers = /* @__PURE__ */ new Map(); + this._requestHandlerAbortControllers = /* @__PURE__ */ new Map(); + this._notificationHandlers = /* @__PURE__ */ new Map(); + this._responseHandlers = /* @__PURE__ */ new Map(); + this._progressHandlers = /* @__PURE__ */ new Map(); + this._timeoutInfo = /* @__PURE__ */ new Map(); + this._pendingDebouncedNotifications = /* @__PURE__ */ new Set(); + this._taskProgressTokens = /* @__PURE__ */ new Map(); + this._requestResolvers = /* @__PURE__ */ new Map(); + this.setNotificationHandler(CancelledNotificationSchema, (notification) => { + this._oncancel(notification); + }); + this.setNotificationHandler(ProgressNotificationSchema, (notification) => { + this._onprogress(notification); + }); + this.setRequestHandler( + PingRequestSchema, + // Automatic pong by default. + (_request) => ({}) + ); + this._taskStore = _options?.taskStore; + this._taskMessageQueue = _options?.taskMessageQueue; + if (this._taskStore) { + this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => { + const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found"); + } + return { + ...task + }; + }); + this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => { + const handleTaskResult = async () => { + const taskId = request.params.taskId; + if (this._taskMessageQueue) { + let queuedMessage; + while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) { + if (queuedMessage.type === "response" || queuedMessage.type === "error") { + const message = queuedMessage.message; + const requestId = message.id; + const resolver = this._requestResolvers.get(requestId); + if (resolver) { + this._requestResolvers.delete(requestId); + if (queuedMessage.type === "response") { + resolver(message); + } else { + const errorMessage = message; + const error2 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data); + resolver(error2); + } + } else { + const messageType = queuedMessage.type === "response" ? "Response" : "Error"; + this._onerror(new Error(`${messageType} handler missing for request ${requestId}`)); + } + continue; + } + await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId }); + } + } + const task = await this._taskStore.getTask(taskId, extra.sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`); + } + if (!isTerminal(task.status)) { + await this._waitForTaskUpdate(taskId, extra.signal); + return await handleTaskResult(); + } + if (isTerminal(task.status)) { + const result = await this._taskStore.getTaskResult(taskId, extra.sessionId); + this._clearTaskQueue(taskId); + return { + ...result, + _meta: { + ...result._meta, + [RELATED_TASK_META_KEY]: { + taskId + } + } + }; + } + return await handleTaskResult(); + }; + return await handleTaskResult(); + }); + this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => { + try { + const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId); + return { + tasks, + nextCursor, + _meta: {} + }; + } catch (error2) { + throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error2 instanceof Error ? error2.message : String(error2)}`); + } + }); + this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => { + try { + const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`); + } + if (isTerminal(task.status)) { + throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`); + } + await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId); + this._clearTaskQueue(request.params.taskId); + const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId); + if (!cancelledTask) { + throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`); + } + return { + _meta: {}, + ...cancelledTask + }; + } catch (error2) { + if (error2 instanceof McpError) { + throw error2; + } + throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error2 instanceof Error ? error2.message : String(error2)}`); + } + }); + } + } + async _oncancel(notification) { + if (!notification.params.requestId) { + return; + } + const controller = this._requestHandlerAbortControllers.get(notification.params.requestId); + controller?.abort(notification.params.reason); + } + _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) { + this._timeoutInfo.set(messageId, { + timeoutId: setTimeout(onTimeout, timeout), + startTime: Date.now(), + timeout, + maxTotalTimeout, + resetTimeoutOnProgress, + onTimeout + }); + } + _resetTimeout(messageId) { + const info = this._timeoutInfo.get(messageId); + if (!info) + return false; + const totalElapsed = Date.now() - info.startTime; + if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) { + this._timeoutInfo.delete(messageId); + throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", { + maxTotalTimeout: info.maxTotalTimeout, + totalElapsed + }); + } + clearTimeout(info.timeoutId); + info.timeoutId = setTimeout(info.onTimeout, info.timeout); + return true; + } + _cleanupTimeout(messageId) { + const info = this._timeoutInfo.get(messageId); + if (info) { + clearTimeout(info.timeoutId); + this._timeoutInfo.delete(messageId); + } + } + /** + * Attaches to the given transport, starts it, and starts listening for messages. + * + * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward. + */ + async connect(transport) { + if (this._transport) { + throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection."); + } + this._transport = transport; + const _onclose = this.transport?.onclose; + this._transport.onclose = () => { + _onclose?.(); + this._onclose(); + }; + const _onerror = this.transport?.onerror; + this._transport.onerror = (error2) => { + _onerror?.(error2); + this._onerror(error2); + }; + const _onmessage = this._transport?.onmessage; + this._transport.onmessage = (message, extra) => { + _onmessage?.(message, extra); + if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) { + this._onresponse(message); + } else if (isJSONRPCRequest(message)) { + this._onrequest(message, extra); + } else if (isJSONRPCNotification(message)) { + this._onnotification(message); + } else { + this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`)); + } + }; + await this._transport.start(); + } + _onclose() { + const responseHandlers = this._responseHandlers; + this._responseHandlers = /* @__PURE__ */ new Map(); + this._progressHandlers.clear(); + this._taskProgressTokens.clear(); + this._pendingDebouncedNotifications.clear(); + for (const controller of this._requestHandlerAbortControllers.values()) { + controller.abort(); + } + this._requestHandlerAbortControllers.clear(); + const error2 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed"); + this._transport = void 0; + this.onclose?.(); + for (const handler of responseHandlers.values()) { + handler(error2); + } + } + _onerror(error2) { + this.onerror?.(error2); + } + _onnotification(notification) { + const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler; + if (handler === void 0) { + return; + } + Promise.resolve().then(() => handler(notification)).catch((error2) => this._onerror(new Error(`Uncaught error in notification handler: ${error2}`))); + } + _onrequest(request, extra) { + const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler; + const capturedTransport = this._transport; + const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId; + if (handler === void 0) { + const errorResponse = { + jsonrpc: "2.0", + id: request.id, + error: { + code: ErrorCode.MethodNotFound, + message: "Method not found" + } + }; + if (relatedTaskId && this._taskMessageQueue) { + this._enqueueTaskMessage(relatedTaskId, { + type: "error", + message: errorResponse, + timestamp: Date.now() + }, capturedTransport?.sessionId).catch((error2) => this._onerror(new Error(`Failed to enqueue error response: ${error2}`))); + } else { + capturedTransport?.send(errorResponse).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`))); + } + return; + } + const abortController = new AbortController(); + this._requestHandlerAbortControllers.set(request.id, abortController); + const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0; + const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : void 0; + const fullExtra = { + signal: abortController.signal, + sessionId: capturedTransport?.sessionId, + _meta: request.params?._meta, + sendNotification: async (notification) => { + if (abortController.signal.aborted) + return; + const notificationOptions = { relatedRequestId: request.id }; + if (relatedTaskId) { + notificationOptions.relatedTask = { taskId: relatedTaskId }; + } + await this.notification(notification, notificationOptions); + }, + sendRequest: async (r, resultSchema, options) => { + if (abortController.signal.aborted) { + throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled"); + } + const requestOptions = { ...options, relatedRequestId: request.id }; + if (relatedTaskId && !requestOptions.relatedTask) { + requestOptions.relatedTask = { taskId: relatedTaskId }; + } + const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId; + if (effectiveTaskId && taskStore) { + await taskStore.updateTaskStatus(effectiveTaskId, "input_required"); + } + return await this.request(r, resultSchema, requestOptions); + }, + authInfo: extra?.authInfo, + requestId: request.id, + requestInfo: extra?.requestInfo, + taskId: relatedTaskId, + taskStore, + taskRequestedTtl: taskCreationParams?.ttl, + closeSSEStream: extra?.closeSSEStream, + closeStandaloneSSEStream: extra?.closeStandaloneSSEStream + }; + Promise.resolve().then(() => { + if (taskCreationParams) { + this.assertTaskHandlerCapability(request.method); + } + }).then(() => handler(request, fullExtra)).then(async (result) => { + if (abortController.signal.aborted) { + return; + } + const response = { + result, + jsonrpc: "2.0", + id: request.id + }; + if (relatedTaskId && this._taskMessageQueue) { + await this._enqueueTaskMessage(relatedTaskId, { + type: "response", + message: response, + timestamp: Date.now() + }, capturedTransport?.sessionId); + } else { + await capturedTransport?.send(response); + } + }, async (error2) => { + if (abortController.signal.aborted) { + return; + } + const errorResponse = { + jsonrpc: "2.0", + id: request.id, + error: { + code: Number.isSafeInteger(error2["code"]) ? error2["code"] : ErrorCode.InternalError, + message: error2.message ?? "Internal error", + ...error2["data"] !== void 0 && { data: error2["data"] } + } + }; + if (relatedTaskId && this._taskMessageQueue) { + await this._enqueueTaskMessage(relatedTaskId, { + type: "error", + message: errorResponse, + timestamp: Date.now() + }, capturedTransport?.sessionId); + } else { + await capturedTransport?.send(errorResponse); + } + }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => { + this._requestHandlerAbortControllers.delete(request.id); + }); + } + _onprogress(notification) { + const { progressToken, ...params } = notification.params; + const messageId = Number(progressToken); + const handler = this._progressHandlers.get(messageId); + if (!handler) { + this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`)); + return; + } + const responseHandler = this._responseHandlers.get(messageId); + const timeoutInfo = this._timeoutInfo.get(messageId); + if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) { + try { + this._resetTimeout(messageId); + } catch (error2) { + this._responseHandlers.delete(messageId); + this._progressHandlers.delete(messageId); + this._cleanupTimeout(messageId); + responseHandler(error2); + return; + } + } + handler(params); + } + _onresponse(response) { + const messageId = Number(response.id); + const resolver = this._requestResolvers.get(messageId); + if (resolver) { + this._requestResolvers.delete(messageId); + if (isJSONRPCResultResponse(response)) { + resolver(response); + } else { + const error2 = new McpError(response.error.code, response.error.message, response.error.data); + resolver(error2); + } + return; + } + const handler = this._responseHandlers.get(messageId); + if (handler === void 0) { + this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`)); + return; + } + this._responseHandlers.delete(messageId); + this._cleanupTimeout(messageId); + let isTaskResponse = false; + if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") { + const result = response.result; + if (result.task && typeof result.task === "object") { + const task = result.task; + if (typeof task.taskId === "string") { + isTaskResponse = true; + this._taskProgressTokens.set(task.taskId, messageId); + } + } + } + if (!isTaskResponse) { + this._progressHandlers.delete(messageId); + } + if (isJSONRPCResultResponse(response)) { + handler(response); + } else { + const error2 = McpError.fromError(response.error.code, response.error.message, response.error.data); + handler(error2); + } + } + get transport() { + return this._transport; + } + /** + * Closes the connection. + */ + async close() { + await this._transport?.close(); + } + /** + * Sends a request and returns an AsyncGenerator that yields response messages. + * The generator is guaranteed to end with either a 'result' or 'error' message. + * + * @example + * ```typescript + * const stream = protocol.requestStream(request, resultSchema, options); + * for await (const message of stream) { + * switch (message.type) { + * case 'taskCreated': + * console.log('Task created:', message.task.taskId); + * break; + * case 'taskStatus': + * console.log('Task status:', message.task.status); + * break; + * case 'result': + * console.log('Final result:', message.result); + * break; + * case 'error': + * console.error('Error:', message.error); + * break; + * } + * } + * ``` + * + * @experimental Use `client.experimental.tasks.requestStream()` to access this method. + */ + async *requestStream(request, resultSchema, options) { + const { task } = options ?? {}; + if (!task) { + try { + const result = await this.request(request, resultSchema, options); + yield { type: "result", result }; + } catch (error2) { + yield { + type: "error", + error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2)) + }; + } + return; + } + let taskId; + try { + const createResult = await this.request(request, CreateTaskResultSchema, options); + if (createResult.task) { + taskId = createResult.task.taskId; + yield { type: "taskCreated", task: createResult.task }; + } else { + throw new McpError(ErrorCode.InternalError, "Task creation did not return a task"); + } + while (true) { + const task2 = await this.getTask({ taskId }, options); + yield { type: "taskStatus", task: task2 }; + if (isTerminal(task2.status)) { + if (task2.status === "completed") { + const result = await this.getTaskResult({ taskId }, resultSchema, options); + yield { type: "result", result }; + } else if (task2.status === "failed") { + yield { + type: "error", + error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`) + }; + } else if (task2.status === "cancelled") { + yield { + type: "error", + error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`) + }; + } + return; + } + if (task2.status === "input_required") { + const result = await this.getTaskResult({ taskId }, resultSchema, options); + yield { type: "result", result }; + return; + } + const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3; + await new Promise((resolve) => setTimeout(resolve, pollInterval)); + options?.signal?.throwIfAborted(); + } + } catch (error2) { + yield { + type: "error", + error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2)) + }; + } + } + /** + * Sends a request and waits for a response. + * + * Do not use this method to emit notifications! Use notification() instead. + */ + request(request, resultSchema, options) { + const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {}; + return new Promise((resolve, reject) => { + const earlyReject = (error2) => { + reject(error2); + }; + if (!this._transport) { + earlyReject(new Error("Not connected")); + return; + } + if (this._options?.enforceStrictCapabilities === true) { + try { + this.assertCapabilityForMethod(request.method); + if (task) { + this.assertTaskCapability(request.method); + } + } catch (e) { + earlyReject(e); + return; + } + } + options?.signal?.throwIfAborted(); + const messageId = this._requestMessageId++; + const jsonrpcRequest = { + ...request, + jsonrpc: "2.0", + id: messageId + }; + if (options?.onprogress) { + this._progressHandlers.set(messageId, options.onprogress); + jsonrpcRequest.params = { + ...request.params, + _meta: { + ...request.params?._meta || {}, + progressToken: messageId + } + }; + } + if (task) { + jsonrpcRequest.params = { + ...jsonrpcRequest.params, + task + }; + } + if (relatedTask) { + jsonrpcRequest.params = { + ...jsonrpcRequest.params, + _meta: { + ...jsonrpcRequest.params?._meta || {}, + [RELATED_TASK_META_KEY]: relatedTask + } + }; + } + const cancel = (reason) => { + this._responseHandlers.delete(messageId); + this._progressHandlers.delete(messageId); + this._cleanupTimeout(messageId); + this._transport?.send({ + jsonrpc: "2.0", + method: "notifications/cancelled", + params: { + requestId: messageId, + reason: String(reason) + } + }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error3) => this._onerror(new Error(`Failed to send cancellation: ${error3}`))); + const error2 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason)); + reject(error2); + }; + this._responseHandlers.set(messageId, (response) => { + if (options?.signal?.aborted) { + return; + } + if (response instanceof Error) { + return reject(response); + } + try { + const parseResult = safeParse2(resultSchema, response.result); + if (!parseResult.success) { + reject(parseResult.error); + } else { + resolve(parseResult.data); + } + } catch (error2) { + reject(error2); + } + }); + options?.signal?.addEventListener("abort", () => { + cancel(options?.signal?.reason); + }); + const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC; + const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout })); + this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false); + const relatedTaskId = relatedTask?.taskId; + if (relatedTaskId) { + const responseResolver = (response) => { + const handler = this._responseHandlers.get(messageId); + if (handler) { + handler(response); + } else { + this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`)); + } + }; + this._requestResolvers.set(messageId, responseResolver); + this._enqueueTaskMessage(relatedTaskId, { + type: "request", + message: jsonrpcRequest, + timestamp: Date.now() + }).catch((error2) => { + this._cleanupTimeout(messageId); + reject(error2); + }); + } else { + this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => { + this._cleanupTimeout(messageId); + reject(error2); + }); + } + }); + } + /** + * Gets the current status of a task. + * + * @experimental Use `client.experimental.tasks.getTask()` to access this method. + */ + async getTask(params, options) { + return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options); + } + /** + * Retrieves the result of a completed task. + * + * @experimental Use `client.experimental.tasks.getTaskResult()` to access this method. + */ + async getTaskResult(params, resultSchema, options) { + return this.request({ method: "tasks/result", params }, resultSchema, options); + } + /** + * Lists tasks, optionally starting from a pagination cursor. + * + * @experimental Use `client.experimental.tasks.listTasks()` to access this method. + */ + async listTasks(params, options) { + return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options); + } + /** + * Cancels a specific task. + * + * @experimental Use `client.experimental.tasks.cancelTask()` to access this method. + */ + async cancelTask(params, options) { + return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options); + } + /** + * Emits a notification, which is a one-way message that does not expect a response. + */ + async notification(notification, options) { + if (!this._transport) { + throw new Error("Not connected"); + } + this.assertNotificationCapability(notification.method); + const relatedTaskId = options?.relatedTask?.taskId; + if (relatedTaskId) { + const jsonrpcNotification2 = { + ...notification, + jsonrpc: "2.0", + params: { + ...notification.params, + _meta: { + ...notification.params?._meta || {}, + [RELATED_TASK_META_KEY]: options.relatedTask + } + } + }; + await this._enqueueTaskMessage(relatedTaskId, { + type: "notification", + message: jsonrpcNotification2, + timestamp: Date.now() + }); + return; + } + const debouncedMethods = this._options?.debouncedNotificationMethods ?? []; + const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask; + if (canDebounce) { + if (this._pendingDebouncedNotifications.has(notification.method)) { + return; + } + this._pendingDebouncedNotifications.add(notification.method); + Promise.resolve().then(() => { + this._pendingDebouncedNotifications.delete(notification.method); + if (!this._transport) { + return; + } + let jsonrpcNotification2 = { + ...notification, + jsonrpc: "2.0" + }; + if (options?.relatedTask) { + jsonrpcNotification2 = { + ...jsonrpcNotification2, + params: { + ...jsonrpcNotification2.params, + _meta: { + ...jsonrpcNotification2.params?._meta || {}, + [RELATED_TASK_META_KEY]: options.relatedTask + } + } + }; + } + this._transport?.send(jsonrpcNotification2, options).catch((error2) => this._onerror(error2)); + }); + return; + } + let jsonrpcNotification = { + ...notification, + jsonrpc: "2.0" + }; + if (options?.relatedTask) { + jsonrpcNotification = { + ...jsonrpcNotification, + params: { + ...jsonrpcNotification.params, + _meta: { + ...jsonrpcNotification.params?._meta || {}, + [RELATED_TASK_META_KEY]: options.relatedTask + } + } + }; + } + await this._transport.send(jsonrpcNotification, options); + } + /** + * Registers a handler to invoke when this protocol object receives a request with the given method. + * + * Note that this will replace any previous request handler for the same method. + */ + setRequestHandler(requestSchema, handler) { + const method = getMethodLiteral(requestSchema); + this.assertRequestHandlerCapability(method); + this._requestHandlers.set(method, (request, extra) => { + const parsed = parseWithCompat(requestSchema, request); + return Promise.resolve(handler(parsed, extra)); + }); + } + /** + * Removes the request handler for the given method. + */ + removeRequestHandler(method) { + this._requestHandlers.delete(method); + } + /** + * Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed. + */ + assertCanSetRequestHandler(method) { + if (this._requestHandlers.has(method)) { + throw new Error(`A request handler for ${method} already exists, which would be overridden`); + } + } + /** + * Registers a handler to invoke when this protocol object receives a notification with the given method. + * + * Note that this will replace any previous notification handler for the same method. + */ + setNotificationHandler(notificationSchema, handler) { + const method = getMethodLiteral(notificationSchema); + this._notificationHandlers.set(method, (notification) => { + const parsed = parseWithCompat(notificationSchema, notification); + return Promise.resolve(handler(parsed)); + }); + } + /** + * Removes the notification handler for the given method. + */ + removeNotificationHandler(method) { + this._notificationHandlers.delete(method); + } + /** + * Cleans up the progress handler associated with a task. + * This should be called when a task reaches a terminal status. + */ + _cleanupTaskProgressHandler(taskId) { + const progressToken = this._taskProgressTokens.get(taskId); + if (progressToken !== void 0) { + this._progressHandlers.delete(progressToken); + this._taskProgressTokens.delete(taskId); + } + } + /** + * Enqueues a task-related message for side-channel delivery via tasks/result. + * @param taskId The task ID to associate the message with + * @param message The message to enqueue + * @param sessionId Optional session ID for binding the operation to a specific session + * @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow) + * + * Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle + * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer + * simply propagates the error. + */ + async _enqueueTaskMessage(taskId, message, sessionId) { + if (!this._taskStore || !this._taskMessageQueue) { + throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured"); + } + const maxQueueSize = this._options?.maxTaskQueueSize; + await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize); + } + /** + * Clears the message queue for a task and rejects any pending request resolvers. + * @param taskId The task ID whose queue should be cleared + * @param sessionId Optional session ID for binding the operation to a specific session + */ + async _clearTaskQueue(taskId, sessionId) { + if (this._taskMessageQueue) { + const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId); + for (const message of messages) { + if (message.type === "request" && isJSONRPCRequest(message.message)) { + const requestId = message.message.id; + const resolver = this._requestResolvers.get(requestId); + if (resolver) { + resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed")); + this._requestResolvers.delete(requestId); + } else { + this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`)); + } + } + } + } + } + /** + * Waits for a task update (new messages or status change) with abort signal support. + * Uses polling to check for updates at the task's configured poll interval. + * @param taskId The task ID to wait for + * @param signal Abort signal to cancel the wait + * @returns Promise that resolves when an update occurs or rejects if aborted + */ + async _waitForTaskUpdate(taskId, signal) { + let interval = this._options?.defaultTaskPollInterval ?? 1e3; + try { + const task = await this._taskStore?.getTask(taskId); + if (task?.pollInterval) { + interval = task.pollInterval; + } + } catch { + } + return new Promise((resolve, reject) => { + if (signal.aborted) { + reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled")); + return; + } + const timeoutId = setTimeout(resolve, interval); + signal.addEventListener("abort", () => { + clearTimeout(timeoutId); + reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled")); + }, { once: true }); + }); + } + requestTaskStore(request, sessionId) { + const taskStore = this._taskStore; + if (!taskStore) { + throw new Error("No task store configured"); + } + return { + createTask: async (taskParams) => { + if (!request) { + throw new Error("No request provided"); + } + return await taskStore.createTask(taskParams, request.id, { + method: request.method, + params: request.params + }, sessionId); + }, + getTask: async (taskId) => { + const task = await taskStore.getTask(taskId, sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found"); + } + return task; + }, + storeTaskResult: async (taskId, status, result) => { + await taskStore.storeTaskResult(taskId, status, result, sessionId); + const task = await taskStore.getTask(taskId, sessionId); + if (task) { + const notification = TaskStatusNotificationSchema.parse({ + method: "notifications/tasks/status", + params: task + }); + await this.notification(notification); + if (isTerminal(task.status)) { + this._cleanupTaskProgressHandler(taskId); + } + } + }, + getTaskResult: (taskId) => { + return taskStore.getTaskResult(taskId, sessionId); + }, + updateTaskStatus: async (taskId, status, statusMessage) => { + const task = await taskStore.getTask(taskId, sessionId); + if (!task) { + throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`); + } + if (isTerminal(task.status)) { + throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`); + } + await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId); + const updatedTask = await taskStore.getTask(taskId, sessionId); + if (updatedTask) { + const notification = TaskStatusNotificationSchema.parse({ + method: "notifications/tasks/status", + params: updatedTask + }); + await this.notification(notification); + if (isTerminal(updatedTask.status)) { + this._cleanupTaskProgressHandler(taskId); + } + } + }, + listTasks: (cursor) => { + return taskStore.listTasks(cursor, sessionId); + } + }; + } +}; +function isPlainObject2(value) { + return value !== null && typeof value === "object" && !Array.isArray(value); +} +function mergeCapabilities(base, additional) { + const result = { ...base }; + for (const key in additional) { + const k = key; + const addValue = additional[k]; + if (addValue === void 0) + continue; + const baseValue = result[k]; + if (isPlainObject2(baseValue) && isPlainObject2(addValue)) { + result[k] = { ...baseValue, ...addValue }; + } else { + result[k] = addValue; + } + } + return result; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js +var import_ajv = __toESM(require_ajv(), 1); +var import_ajv_formats = __toESM(require_dist(), 1); +function createDefaultAjvInstance() { + const ajv = new import_ajv.default({ + strict: false, + validateFormats: true, + validateSchema: false, + allErrors: true + }); + const addFormats = import_ajv_formats.default; + addFormats(ajv); + return ajv; +} +var AjvJsonSchemaValidator = class { + /** + * Create an AJV validator + * + * @param ajv - Optional pre-configured AJV instance. If not provided, a default instance will be created. + * + * @example + * ```typescript + * // Use default configuration (recommended for most cases) + * import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv'; + * const validator = new AjvJsonSchemaValidator(); + * + * // Or provide custom AJV instance for advanced configuration + * import { Ajv } from 'ajv'; + * import addFormats from 'ajv-formats'; + * + * const ajv = new Ajv({ validateFormats: true }); + * addFormats(ajv); + * const validator = new AjvJsonSchemaValidator(ajv); + * ``` + */ + constructor(ajv) { + this._ajv = ajv ?? createDefaultAjvInstance(); + } + /** + * Create a validator for the given JSON Schema + * + * The validator is compiled once and can be reused multiple times. + * If the schema has an $id, it will be cached by AJV automatically. + * + * @param schema - Standard JSON Schema object + * @returns A validator function that validates input data + */ + getValidator(schema) { + const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema); + return (input) => { + const valid = ajvValidator(input); + if (valid) { + return { + valid: true, + data: input, + errorMessage: void 0 + }; + } else { + return { + valid: false, + data: void 0, + errorMessage: this._ajv.errorsText(ajvValidator.errors) + }; + } + }; + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js +var ExperimentalServerTasks = class { + constructor(_server) { + this._server = _server; + } + /** + * Sends a request and returns an AsyncGenerator that yields response messages. + * The generator is guaranteed to end with either a 'result' or 'error' message. + * + * This method provides streaming access to request processing, allowing you to + * observe intermediate task status updates for task-augmented requests. + * + * @param request - The request to send + * @param resultSchema - Zod schema for validating the result + * @param options - Optional request options (timeout, signal, task creation params, etc.) + * @returns AsyncGenerator that yields ResponseMessage objects + * + * @experimental + */ + requestStream(request, resultSchema, options) { + return this._server.requestStream(request, resultSchema, options); + } + /** + * Gets the current status of a task. + * + * @param taskId - The task identifier + * @param options - Optional request options + * @returns The task status + * + * @experimental + */ + async getTask(taskId, options) { + return this._server.getTask({ taskId }, options); + } + /** + * Retrieves the result of a completed task. + * + * @param taskId - The task identifier + * @param resultSchema - Zod schema for validating the result + * @param options - Optional request options + * @returns The task result + * + * @experimental + */ + async getTaskResult(taskId, resultSchema, options) { + return this._server.getTaskResult({ taskId }, resultSchema, options); + } + /** + * Lists tasks with optional pagination. + * + * @param cursor - Optional pagination cursor + * @param options - Optional request options + * @returns List of tasks with optional next cursor + * + * @experimental + */ + async listTasks(cursor, options) { + return this._server.listTasks(cursor ? { cursor } : void 0, options); + } + /** + * Cancels a running task. + * + * @param taskId - The task identifier + * @param options - Optional request options + * + * @experimental + */ + async cancelTask(taskId, options) { + return this._server.cancelTask({ taskId }, options); + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js +function assertToolsCallTaskCapability(requests, method, entityName) { + if (!requests) { + throw new Error(`${entityName} does not support task creation (required for ${method})`); + } + switch (method) { + case "tools/call": + if (!requests.tools?.call) { + throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`); + } + break; + default: + break; + } +} +function assertClientRequestTaskCapability(requests, method, entityName) { + if (!requests) { + throw new Error(`${entityName} does not support task creation (required for ${method})`); + } + switch (method) { + case "sampling/createMessage": + if (!requests.sampling?.createMessage) { + throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`); + } + break; + case "elicitation/create": + if (!requests.elicitation?.create) { + throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`); + } + break; + default: + break; + } +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js +var Server = class extends Protocol { + /** + * Initializes this server with the given name and version information. + */ + constructor(_serverInfo, options) { + super(options); + this._serverInfo = _serverInfo; + this._loggingLevels = /* @__PURE__ */ new Map(); + this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index])); + this.isMessageIgnored = (level, sessionId) => { + const currentLevel = this._loggingLevels.get(sessionId); + return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false; + }; + this._capabilities = options?.capabilities ?? {}; + this._instructions = options?.instructions; + this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator(); + this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request)); + this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.()); + if (this._capabilities.logging) { + this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => { + const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0; + const { level } = request.params; + const parseResult = LoggingLevelSchema.safeParse(level); + if (parseResult.success) { + this._loggingLevels.set(transportSessionId, parseResult.data); + } + return {}; + }); + } + } + /** + * Access experimental features. + * + * WARNING: These APIs are experimental and may change without notice. + * + * @experimental + */ + get experimental() { + if (!this._experimental) { + this._experimental = { + tasks: new ExperimentalServerTasks(this) + }; + } + return this._experimental; + } + /** + * Registers new capabilities. This can only be called before connecting to a transport. + * + * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization). + */ + registerCapabilities(capabilities) { + if (this.transport) { + throw new Error("Cannot register capabilities after connecting to transport"); + } + this._capabilities = mergeCapabilities(this._capabilities, capabilities); + } + /** + * Override request handler registration to enforce server-side validation for tools/call. + */ + setRequestHandler(requestSchema, handler) { + const shape = getObjectShape(requestSchema); + const methodSchema = shape?.method; + if (!methodSchema) { + throw new Error("Schema is missing a method literal"); + } + let methodValue; + if (isZ4Schema(methodSchema)) { + const v4Schema = methodSchema; + const v4Def = v4Schema._zod?.def; + methodValue = v4Def?.value ?? v4Schema.value; + } else { + const v3Schema = methodSchema; + const legacyDef = v3Schema._def; + methodValue = legacyDef?.value ?? v3Schema.value; + } + if (typeof methodValue !== "string") { + throw new Error("Schema method literal must be a string"); + } + const method = methodValue; + if (method === "tools/call") { + const wrappedHandler = async (request, extra) => { + const validatedRequest = safeParse2(CallToolRequestSchema, request); + if (!validatedRequest.success) { + const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`); + } + const { params } = validatedRequest.data; + const result = await Promise.resolve(handler(request, extra)); + if (params.task) { + const taskValidationResult = safeParse2(CreateTaskResultSchema, result); + if (!taskValidationResult.success) { + const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`); + } + return taskValidationResult.data; + } + const validationResult = safeParse2(CallToolResultSchema, result); + if (!validationResult.success) { + const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error); + throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`); + } + return validationResult.data; + }; + return super.setRequestHandler(requestSchema, wrappedHandler); + } + return super.setRequestHandler(requestSchema, handler); + } + assertCapabilityForMethod(method) { + switch (method) { + case "sampling/createMessage": + if (!this._clientCapabilities?.sampling) { + throw new Error(`Client does not support sampling (required for ${method})`); + } + break; + case "elicitation/create": + if (!this._clientCapabilities?.elicitation) { + throw new Error(`Client does not support elicitation (required for ${method})`); + } + break; + case "roots/list": + if (!this._clientCapabilities?.roots) { + throw new Error(`Client does not support listing roots (required for ${method})`); + } + break; + case "ping": + break; + } + } + assertNotificationCapability(method) { + switch (method) { + case "notifications/message": + if (!this._capabilities.logging) { + throw new Error(`Server does not support logging (required for ${method})`); + } + break; + case "notifications/resources/updated": + case "notifications/resources/list_changed": + if (!this._capabilities.resources) { + throw new Error(`Server does not support notifying about resources (required for ${method})`); + } + break; + case "notifications/tools/list_changed": + if (!this._capabilities.tools) { + throw new Error(`Server does not support notifying of tool list changes (required for ${method})`); + } + break; + case "notifications/prompts/list_changed": + if (!this._capabilities.prompts) { + throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`); + } + break; + case "notifications/elicitation/complete": + if (!this._clientCapabilities?.elicitation?.url) { + throw new Error(`Client does not support URL elicitation (required for ${method})`); + } + break; + case "notifications/cancelled": + break; + case "notifications/progress": + break; + } + } + assertRequestHandlerCapability(method) { + if (!this._capabilities) { + return; + } + switch (method) { + case "completion/complete": + if (!this._capabilities.completions) { + throw new Error(`Server does not support completions (required for ${method})`); + } + break; + case "logging/setLevel": + if (!this._capabilities.logging) { + throw new Error(`Server does not support logging (required for ${method})`); + } + break; + case "prompts/get": + case "prompts/list": + if (!this._capabilities.prompts) { + throw new Error(`Server does not support prompts (required for ${method})`); + } + break; + case "resources/list": + case "resources/templates/list": + case "resources/read": + if (!this._capabilities.resources) { + throw new Error(`Server does not support resources (required for ${method})`); + } + break; + case "tools/call": + case "tools/list": + if (!this._capabilities.tools) { + throw new Error(`Server does not support tools (required for ${method})`); + } + break; + case "tasks/get": + case "tasks/list": + case "tasks/result": + case "tasks/cancel": + if (!this._capabilities.tasks) { + throw new Error(`Server does not support tasks capability (required for ${method})`); + } + break; + case "ping": + case "initialize": + break; + } + } + assertTaskCapability(method) { + assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client"); + } + assertTaskHandlerCapability(method) { + if (!this._capabilities) { + return; + } + assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server"); + } + async _oninitialize(request) { + const requestedVersion = request.params.protocolVersion; + this._clientCapabilities = request.params.capabilities; + this._clientVersion = request.params.clientInfo; + const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION; + return { + protocolVersion, + capabilities: this.getCapabilities(), + serverInfo: this._serverInfo, + ...this._instructions && { instructions: this._instructions } + }; + } + /** + * After initialization has completed, this will be populated with the client's reported capabilities. + */ + getClientCapabilities() { + return this._clientCapabilities; + } + /** + * After initialization has completed, this will be populated with information about the client's name and version. + */ + getClientVersion() { + return this._clientVersion; + } + getCapabilities() { + return this._capabilities; + } + async ping() { + return this.request({ method: "ping" }, EmptyResultSchema); + } + // Implementation + async createMessage(params, options) { + if (params.tools || params.toolChoice) { + if (!this._clientCapabilities?.sampling?.tools) { + throw new Error("Client does not support sampling tools capability."); + } + } + if (params.messages.length > 0) { + const lastMessage = params.messages[params.messages.length - 1]; + const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content]; + const hasToolResults = lastContent.some((c) => c.type === "tool_result"); + const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0; + const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : []; + const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use"); + if (hasToolResults) { + if (lastContent.some((c) => c.type !== "tool_result")) { + throw new Error("The last message must contain only tool_result content if any is present"); + } + if (!hasPreviousToolUse) { + throw new Error("tool_result blocks are not matching any tool_use from the previous message"); + } + } + if (hasPreviousToolUse) { + const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id)); + const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId)); + if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) { + throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match"); + } + } + } + if (params.tools) { + return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options); + } + return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options); + } + /** + * Creates an elicitation request for the given parameters. + * For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`. + * @param params The parameters for the elicitation request. + * @param options Optional request options. + * @returns The result of the elicitation request. + */ + async elicitInput(params, options) { + const mode = params.mode ?? "form"; + switch (mode) { + case "url": { + if (!this._clientCapabilities?.elicitation?.url) { + throw new Error("Client does not support url elicitation."); + } + const urlParams = params; + return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options); + } + case "form": { + if (!this._clientCapabilities?.elicitation?.form) { + throw new Error("Client does not support form elicitation."); + } + const formParams = params.mode === "form" ? params : { ...params, mode: "form" }; + const result = await this.request({ method: "elicitation/create", params: formParams }, ElicitResultSchema, options); + if (result.action === "accept" && result.content && formParams.requestedSchema) { + try { + const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema); + const validationResult = validator(result.content); + if (!validationResult.valid) { + throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`); + } + } catch (error2) { + if (error2 instanceof McpError) { + throw error2; + } + throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error2 instanceof Error ? error2.message : String(error2)}`); + } + } + return result; + } + } + } + /** + * Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete` + * notification for the specified elicitation ID. + * + * @param elicitationId The ID of the elicitation to mark as complete. + * @param options Optional notification options. Useful when the completion notification should be related to a prior request. + * @returns A function that emits the completion notification when awaited. + */ + createElicitationCompletionNotifier(elicitationId, options) { + if (!this._clientCapabilities?.elicitation?.url) { + throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)"); + } + return () => this.notification({ + method: "notifications/elicitation/complete", + params: { + elicitationId + } + }, options); + } + async listRoots(params, options) { + return this.request({ method: "roots/list", params }, ListRootsResultSchema, options); + } + /** + * Sends a logging message to the client, if connected. + * Note: You only need to send the parameters object, not the entire JSON RPC message + * @see LoggingMessageNotification + * @param params + * @param sessionId optional for stateless and backward compatibility + */ + async sendLoggingMessage(params, sessionId) { + if (this._capabilities.logging) { + if (!this.isMessageIgnored(params.level, sessionId)) { + return this.notification({ method: "notifications/message", params }); + } + } + } + async sendResourceUpdated(params) { + return this.notification({ + method: "notifications/resources/updated", + params + }); + } + async sendResourceListChanged() { + return this.notification({ + method: "notifications/resources/list_changed" + }); + } + async sendToolListChanged() { + return this.notification({ method: "notifications/tools/list_changed" }); + } + async sendPromptListChanged() { + return this.notification({ method: "notifications/prompts/list_changed" }); + } +}; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js +import process3 from "node:process"; + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js +var ReadBuffer = class { + append(chunk) { + this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk; + } + readMessage() { + if (!this._buffer) { + return null; + } + const index = this._buffer.indexOf("\n"); + if (index === -1) { + return null; + } + const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, ""); + this._buffer = this._buffer.subarray(index + 1); + return deserializeMessage(line); + } + clear() { + this._buffer = void 0; + } +}; +function deserializeMessage(line) { + return JSONRPCMessageSchema.parse(JSON.parse(line)); +} +function serializeMessage(message) { + return JSON.stringify(message) + "\n"; +} + +// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js +var StdioServerTransport = class { + constructor(_stdin = process3.stdin, _stdout = process3.stdout) { + this._stdin = _stdin; + this._stdout = _stdout; + this._readBuffer = new ReadBuffer(); + this._started = false; + this._ondata = (chunk) => { + this._readBuffer.append(chunk); + this.processReadBuffer(); + }; + this._onerror = (error2) => { + this.onerror?.(error2); + }; + } + /** + * Starts listening for messages on stdin. + */ + async start() { + if (this._started) { + throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically."); + } + this._started = true; + this._stdin.on("data", this._ondata); + this._stdin.on("error", this._onerror); + } + processReadBuffer() { + while (true) { + try { + const message = this._readBuffer.readMessage(); + if (message === null) { + break; + } + this.onmessage?.(message); + } catch (error2) { + this.onerror?.(error2); + } + } + } + async close() { + this._stdin.off("data", this._ondata); + this._stdin.off("error", this._onerror); + const remainingDataListeners = this._stdin.listenerCount("data"); + if (remainingDataListeners === 0) { + this._stdin.pause(); + } + this._readBuffer.clear(); + this.onclose?.(); + } + send(message) { + return new Promise((resolve) => { + const json2 = serializeMessage(message); + if (this._stdout.write(json2)) { + resolve(); + } else { + this._stdout.once("drain", resolve); + } + }); + } +}; + +// src/tokens.js +import * as fs2 from "fs/promises"; +import * as crypto from "crypto"; + +// src/config.js +var dotenv = __toESM(require_main(), 1); +import * as path2 from "path"; +import * as os2 from "os"; +import * as fs from "fs/promises"; + +// node_modules/env-paths/index.js +import path from "node:path"; +import os from "node:os"; +import process4 from "node:process"; +var homedir = os.homedir(); +var tmpdir = os.tmpdir(); +var { env } = process4; +var macos = (name) => { + const library = path.join(homedir, "Library"); + return { + data: path.join(library, "Application Support", name), + config: path.join(library, "Preferences", name), + cache: path.join(library, "Caches", name), + log: path.join(library, "Logs", name), + temp: path.join(tmpdir, name) + }; +}; +var windows = (name) => { + const appData = env.APPDATA || path.join(homedir, "AppData", "Roaming"); + const localAppData = env.LOCALAPPDATA || path.join(homedir, "AppData", "Local"); + return { + // Data/config/cache/log are invented by me as Windows isn't opinionated about this + data: path.join(localAppData, name, "Data"), + config: path.join(appData, name, "Config"), + cache: path.join(localAppData, name, "Cache"), + log: path.join(localAppData, name, "Log"), + temp: path.join(tmpdir, name) + }; +}; +var linux = (name) => { + const username = path.basename(homedir); + return { + data: path.join(env.XDG_DATA_HOME || path.join(homedir, ".local", "share"), name), + config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, ".config"), name), + cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, ".cache"), name), + // https://wiki.debian.org/XDGBaseDirectorySpecification#state + log: path.join(env.XDG_STATE_HOME || path.join(homedir, ".local", "state"), name), + temp: path.join(tmpdir, username, name) + }; +}; +function envPaths(name, { suffix = "nodejs" } = {}) { + if (typeof name !== "string") { + throw new TypeError(`Expected a string, got ${typeof name}`); + } + if (suffix) { + name += `-${suffix}`; + } + if (process4.platform === "darwin") { + return macos(name); + } + if (process4.platform === "win32") { + return windows(name); + } + return linux(name); +} + +// src/config.js +var HOME_DIR = os2.homedir(); +var CONFIG_DIR = path2.join(HOME_DIR, ".webmcp"); +var ensureConfigDir = async () => { + try { + await fs.mkdir(CONFIG_DIR, { recursive: true }); + } catch (error2) { + console.error(`Error creating config directory at ${CONFIG_DIR}:`, error2); + } +}; +var PID_FILE = path2.join(CONFIG_DIR, ".webmcp-server.pid"); +var ENV_FILE = path2.join(CONFIG_DIR, ".env"); +var TOKENS_FILE = path2.join(CONFIG_DIR, ".webmcp-tokens.json"); +dotenv.config({ path: ENV_FILE }); +var SERVER_TOKEN = process.env.WEBMCP_SERVER_TOKEN || ""; +var HOST = "localhost"; +var CONFIG = {}; +function setConfig(args) { + Object.entries(args).forEach(([key, value]) => { + CONFIG[key] = value; + }); +} +function formatChannel(channel) { + return `/${channel.replace(/[.:]/g, "_")}`; +} +async function exists(somePath) { + try { + await fs.access(somePath); + return true; + } catch (e) { + return false; + } +} +async function configureMcpClientWithPath(clientConfigPath) { + const directory = path2.dirname(clientConfigPath); + if (!await exists(directory)) { + await fs.mkdir(directory, { recursive: true }); + } + const webmcpConfig = { + "webmcp": { + "command": "npx", + "args": [ + "-y", + "@nucleoriofrio/webmcp@latest", + "--mcp" + ] + } + }; + let json2 = { mcpServers: {} }; + if (await exists(clientConfigPath)) { + const rawJSON = await fs.readFile(clientConfigPath); + try { + json2 = JSON.parse(rawJSON); + } catch (e) { + throw new Error(`Failed to update MCP client configuration: ${e}`); + } + } + json2.mcpServers = { ...json2.mcpServers, ...webmcpConfig }; + await fs.writeFile(clientConfigPath, JSON.stringify(json2, null, 2)); +} +var availableClientConfigs = { + "claude": [envPaths("Claude", { suffix: "" }).data, "claude_desktop_config.json"], + "cline": [envPaths("Code", { suffix: "" }).data, "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"], + "cursor": [HOME_DIR, ".cursor", "mcp.json"], + "windsurf": [HOME_DIR, ".codeium", "windsurf", "mcp_config.json"] +}; +async function configureMcpClient(clientType) { + let clientConfigPath = availableClientConfigs[clientType]; + if (clientConfigPath) { + await configureMcpClientWithPath(clientConfigPath); + } else { + console.error("Unsupported client - treating it like a path..."); + await configureMcpClientWithPath(clientType); + } +} + +// src/tokens.js +function generateToken() { + return crypto.randomBytes(16).toString("hex"); +} +var authorizedTokens = {}; +function getToken(channel) { + return authorizedTokens[channel]; +} +function setToken(channel, value) { + authorizedTokens[channel] = value; +} +function deleteToken(channel) { + delete authorizedTokens[channel]; +} +function clearTokens(channel) { + authorizedTokens = {}; +} +async function loadAuthorizedTokens() { + try { + const data = await fs2.readFile(TOKENS_FILE, "utf8"); + authorizedTokens = JSON.parse(data || "{}"); + return true; + } catch (error2) { + if (error2.code === "ENOENT") { + authorizedTokens = {}; + return true; + } + console.error("Error loading authorized tokens:", error2); + return false; + } +} +async function saveAuthorizedTokens() { + try { + const stringified = JSON.stringify(authorizedTokens, null, 2); + await fs2.writeFile(TOKENS_FILE, stringified, "utf8"); + return true; + } catch (error2) { + console.error("Error saving authorized tokens:", error2); + return false; + } +} +async function saveServerTokenToEnv(token) { + try { + let envContent = ""; + try { + envContent = await fs2.readFile(ENV_FILE, "utf8"); + if (envContent.includes("WEBMCP_SERVER_TOKEN=")) { + envContent = envContent.replace(/WEBMCP_SERVER_TOKEN=.*(\r?\n|$)/g, `WEBMCP_SERVER_TOKEN=${token}$1`); + } else { + envContent += ` +WEBMCP_SERVER_TOKEN=${token} +`; + } + } catch (err) { + envContent = `WEBMCP_SERVER_TOKEN=${token} +`; + } + await fs2.writeFile(ENV_FILE, envContent, "utf8"); + console.error(`Server token saved to ${ENV_FILE}`); + return true; + } catch (error2) { + console.error("Error saving server token to .env file:", error2); + return false; + } +} +async function generateNewRegistrationToken() { + const token = generateToken(); + const address = `${HOST}:${CONFIG.port}`; + const serverAddress = `ws://${address}`; + const connectionData = { + server: serverAddress, + token + }; + const jsonStr = JSON.stringify(connectionData); + const encodedData = Buffer.from(jsonStr).toString("base64"); + setToken(formatChannel(address), token); + await saveAuthorizedTokens(); + return encodedData; +} + +// src/server.js +import { execSync } from "child_process"; +var mcpServer = new Server( + { + name: "@nucleoriofrio/webmcp", + version: "0.2.0" + }, + { + capabilities: { + tools: { + listChanged: true + }, + prompts: { + listChanged: true + }, + resources: { + listChanged: true, + subscribe: true + }, + sampling: {} + } + } +); +var wsClient = null; +var MCP_PATH = "/mcp"; +var pendingRequests = /* @__PURE__ */ new Map(); +var requestIdCounter = 1; +var toolListChangedTimer = null; +var promptListChangedTimer = null; +var resourceListChangedTimer = null; +var LIST_CHANGED_DEBOUNCE_MS = 500; +function debouncedToolListChanged() { + if (toolListChangedTimer) clearTimeout(toolListChangedTimer); + toolListChangedTimer = setTimeout(async () => { + toolListChangedTimer = null; + try { + await mcpServer.sendToolListChanged(); + } catch (e) { + console.error("Error sending tool list changed:", e); + } + }, LIST_CHANGED_DEBOUNCE_MS); +} +function debouncedPromptListChanged() { + if (promptListChangedTimer) clearTimeout(promptListChangedTimer); + promptListChangedTimer = setTimeout(async () => { + promptListChangedTimer = null; + try { + await mcpServer.sendPromptListChanged(); + } catch (e) { + console.error("Error sending prompt list changed:", e); + } + }, LIST_CHANGED_DEBOUNCE_MS); +} +function debouncedResourceListChanged() { + if (resourceListChangedTimer) clearTimeout(resourceListChangedTimer); + resourceListChangedTimer = setTimeout(async () => { + resourceListChangedTimer = null; + try { + await mcpServer.sendResourceListChanged(); + } catch (e) { + console.error("Error sending resource list changed:", e); + } + }, LIST_CHANGED_DEBOUNCE_MS); +} +async function handleWebSocketMessage(message) { + try { + const data = JSON.parse(message); + console.error(`Received message: ${data.type}`); + if (data.type === "toolResponse") { + const { id, result, error: error2 } = data; + if (pendingRequests.has(id)) { + const { resolve, reject } = pendingRequests.get(id); + pendingRequests.delete(id); + if (error2) { + reject(new Error(error2)); + } else { + resolve(result); + } + } else { + console.error(`No pending request found for ID: ${id}`); + } + } else if (data.type === "promptResponse") { + const { id, result, error: error2 } = data; + if (pendingRequests.has(id)) { + const { resolve, reject } = pendingRequests.get(id); + pendingRequests.delete(id); + if (error2) { + reject(new Error(error2)); + } else { + resolve(result); + } + } else { + console.error(`No pending request found for ID: ${id}`); + } + } else if (data.type === "resourceResponse") { + const { id, result, error: error2 } = data; + if (pendingRequests.has(id)) { + const { resolve, reject } = pendingRequests.get(id); + pendingRequests.delete(id); + if (error2) { + reject(new Error(error2)); + } else { + resolve(result); + } + } else { + console.error(`No pending request found for ID: ${id}`); + } + } else if (data.type === "samplingResponse") { + const { id, result, error: error2 } = data; + if (pendingRequests.has(id)) { + const { resolve, reject } = pendingRequests.get(id); + pendingRequests.delete(id); + if (error2) { + reject(new Error(error2)); + } else { + resolve(result); + } + } else { + console.error(`No pending request found for ID: ${id}`); + } + } else if (data.type === "listToolsResponse") { + const { id, tools, error: error2 } = data; + if (pendingRequests.has(id)) { + const { resolve, reject } = pendingRequests.get(id); + pendingRequests.delete(id); + if (error2) { + reject(new Error(error2)); + } else { + resolve(tools); + } + } else { + console.error(`No pending request found for ID: ${id}`); + } + } else if (data.type === "listPromptsResponse") { + const { id, prompts, error: error2 } = data; + if (pendingRequests.has(id)) { + const { resolve, reject } = pendingRequests.get(id); + pendingRequests.delete(id); + if (error2) { + reject(new Error(error2)); + } else { + resolve(prompts); + } + } else { + console.error(`No pending request found for ID: ${id}`); + } + } else if (data.type === "listResourcesResponse") { + const { id, resources, resourceTemplates, error: error2 } = data; + if (pendingRequests.has(id)) { + const { resolve, reject } = pendingRequests.get(id); + pendingRequests.delete(id); + if (error2) { + reject(new Error(error2)); + } else { + resolve({ resources, resourceTemplates }); + } + } else { + console.error(`No pending request found for ID: ${id}`); + } + } else if (data.type === "toolRegistered") { + debouncedToolListChanged(); + } else if (data.type === "resourceRegistered") { + debouncedResourceListChanged(); + } else if (data.type === "promptRegistered") { + debouncedPromptListChanged(); + } else if (data.type === "welcome") { + console.error(`Connected to path: ${data.channel}`); + } else if (data.type === "pong") { + console.error(`Received pong with timestamp: ${data.timestamp}`); + } else if (data.type === "error") { + console.error(`Received error: ${data.message}`); + } + } catch (error2) { + console.error("Error processing WebSocket message:", error2); + } +} +function connectToWebSocketServer(serverToken2) { + const serverUrl = `ws://localhost:${CONFIG.port}${MCP_PATH}?token=${serverToken2}`; + console.error(`Connecting to WebSocket server at ${MCP_PATH} with authentication...`); + wsClient = new wrapper_default(serverUrl); + wsClient.on("open", () => { + console.error(`Connected to WebSocket server on path: ${MCP_PATH}`); + }); + wsClient.on("message", (message) => { + handleWebSocketMessage(message); + }); + wsClient.on("close", (code, reason) => { + console.error(`WebSocket connection closed: ${code} ${reason}`); + wsClient = null; + setTimeout(connectToWebSocketServer, 5e3); + }); + wsClient.on("error", (error2) => { + console.error("WebSocket connection error:", error2); + }); +} +function sendMessage(message) { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + console.error("Cannot send message: WebSocket not connected"); + return Promise.reject(new Error("WebSocket not connected")); + } + try { + wsClient.send(JSON.stringify(message)); + return Promise.resolve(); + } catch (error2) { + console.error("Error sending message:", error2); + return Promise.reject(error2); + } +} +mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => { + if (request.params.name === "_webmcp_get-token") { + const token = await generateNewRegistrationToken(); + try { + execSync("clip.exe", { input: token, stdio: ["pipe", "ignore", "ignore"] }); + } catch (e) { + try { + execSync("xclip -selection clipboard", { input: token, stdio: ["pipe", "ignore", "ignore"] }); + } catch (e2) { + } + } + try { + await sendMessage({ + type: "clipboardCopy", + text: token + }); + } catch (e) { + } + return { + content: [{ + type: "text", + text: `Token copiado al portapapeles. +${token}` + }] + }; + } + if (request.params.name === "_webmcp_clear-cache") { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { content: [{ type: "text", text: "No hay conexion al servidor WebSocket" }], isError: true }; + } + const requestId2 = (requestIdCounter++).toString(); + const responsePromise2 = new Promise((resolve, reject) => { + pendingRequests.set(requestId2, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId2)) { + pendingRequests.delete(requestId2); + reject(new Error("Clear cache timeout")); + } + }, 1e4); + }); + try { + await sendMessage({ id: requestId2, type: "clearRegistry" }); + const result = await responsePromise2; + await mcpServer.sendToolListChanged(); + await mcpServer.sendPromptListChanged(); + await mcpServer.sendResourceListChanged(); + return { content: [{ type: "text", text: result }] }; + } catch (e) { + return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true }; + } + } + if (request.params.name === "_webmcp_browser-info") { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { content: [{ type: "text", text: "No hay conexion al servidor WebSocket" }], isError: true }; + } + const requestId2 = (requestIdCounter++).toString(); + const responsePromise2 = new Promise((resolve, reject) => { + pendingRequests.set(requestId2, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId2)) { + pendingRequests.delete(requestId2); + reject(new Error("Timeout obteniendo info de navegadores")); + } + }, 1e4); + }); + try { + await sendMessage({ id: requestId2, type: "getClientInfo" }); + const result = await responsePromise2; + return result; + } catch (e) { + return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true }; + } + } + if (request.params.name === "_webmcp_agregar-tool") { + if (!CONFIG.dev) { + return { content: [{ type: "text", text: "agregar-tool solo esta disponible en modo desarrollo (--dev)" }], isError: true }; + } + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { content: [{ type: "text", text: "No hay conexion al servidor WebSocket" }], isError: true }; + } + const { nombre, descripcion, codigo, parametros } = request.params.arguments; + if (!nombre || !descripcion || !codigo) { + return { content: [{ type: "text", text: "Se requieren: nombre, descripcion y codigo" }], isError: true }; + } + const requestId2 = (requestIdCounter++).toString(); + const responsePromise2 = new Promise((resolve, reject) => { + pendingRequests.set(requestId2, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId2)) { + pendingRequests.delete(requestId2); + reject(new Error("Timeout creando herramienta")); + } + }, 15e3); + }); + try { + await sendMessage({ + id: requestId2, + type: "createTool", + name: nombre, + description: descripcion, + code: codigo, + parametros + }); + const result = await responsePromise2; + await mcpServer.sendToolListChanged(); + return result; + } catch (e) { + return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true }; + } + } + if (request.params.name === "_webmcp_quitar-tool") { + if (!CONFIG.dev) { + return { content: [{ type: "text", text: "quitar-tool solo esta disponible en modo desarrollo (--dev)" }], isError: true }; + } + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { content: [{ type: "text", text: "No hay conexion al servidor WebSocket" }], isError: true }; + } + const { nombre, listar, todas } = request.params.arguments || {}; + const requestId2 = (requestIdCounter++).toString(); + const responsePromise2 = new Promise((resolve, reject) => { + pendingRequests.set(requestId2, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId2)) { + pendingRequests.delete(requestId2); + reject(new Error("Timeout")); + } + }, 1e4); + }); + try { + await sendMessage({ + id: requestId2, + type: "removeTool", + name: nombre, + listar: !!listar, + todas: !!todas + }); + const result = await responsePromise2; + await mcpServer.sendToolListChanged(); + return result; + } catch (e) { + return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true }; + } + } + if (request.params.name === "_webmcp_server-info") { + if (!CONFIG.dev) { + return { content: [{ type: "text", text: "server-info solo esta disponible en modo desarrollo (--dev)" }], isError: true }; + } + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { content: [{ type: "text", text: "No hay conexion al servidor WebSocket" }], isError: true }; + } + const requestId2 = (requestIdCounter++).toString(); + const responsePromise2 = new Promise((resolve, reject) => { + pendingRequests.set(requestId2, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId2)) { + pendingRequests.delete(requestId2); + reject(new Error("Timeout obteniendo info del servidor")); + } + }, 1e4); + }); + try { + await sendMessage({ id: requestId2, type: "getServerInfo" }); + const result = await responsePromise2; + return result; + } catch (e) { + return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true }; + } + } + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { + content: [{ + type: "text", + text: "Not connected to WebSocket server" + }], + isError: true + }; + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error(`Tool call timed out: ${request.params.name}`)); + } + }, 3e4); + }); + try { + await sendMessage({ + id: requestId, + type: "callTool", + tool: request.params.name, + arguments: request.params.arguments + }); + return await responsePromise; + } catch (error2) { + return { + content: [{ + type: "text", + text: `Error: ${error2.message}` + }], + isError: true + }; + } +}); +mcpServer.setRequestHandler(ListToolsRequestSchema, async () => { + const builtInTools = [ + { + name: "_webmcp_get-token", + description: "Genera un token de conexion para vincular un navegador con @nucleoriofrio/webmcp. El usuario puede decir 'registrar token' o 'conectar webmcp'.", + inputSchema: { + type: "object", + properties: {} + } + }, + { + name: "_webmcp_clear-cache", + description: "Limpia todas las herramientas, prompts y recursos registrados en el cache del servidor @nucleoriofrio/webmcp. Usar para forzar un estado limpio.", + inputSchema: { + type: "object", + properties: {} + } + }, + { + name: "_webmcp_browser-info", + description: "Muestra informacion de los navegadores conectados: user agent, URL, hostname, idioma, resolucion y tiempo de conexion.", + inputSchema: { + type: "object", + properties: {} + } + } + ]; + if (CONFIG.dev) { + builtInTools.push( + { + name: "_webmcp_agregar-tool", + description: "[DEV] Registra una nueva herramienta dinamicamente. El agente puede usar esto para crear herramientas nuevas en tiempo real.", + inputSchema: { + type: "object", + properties: { + nombre: { type: "string", description: "Nombre de la herramienta" }, + descripcion: { type: "string", description: "Descripcion de lo que hace" }, + parametros: { type: "string", description: 'JSON string con las properties del schema, ej: {"msg":{"type":"string","description":"mensaje"}}' }, + codigo: { type: "string", description: 'Codigo JavaScript del body de la funcion. Recibe "args" como parametro. Debe retornar un string.' } + }, + required: ["nombre", "descripcion", "codigo"] + } + }, + { + name: "_webmcp_quitar-tool", + description: "[DEV] Desregistra herramientas. Usa listar=true para ver las disponibles, todas=true para quitar todas, o nombre para quitar una especifica.", + inputSchema: { + type: "object", + properties: { + nombre: { type: "string", description: "Nombre de la herramienta a quitar" }, + listar: { type: "boolean", description: "Si es true, lista las herramientas en vez de quitar" }, + todas: { type: "boolean", description: "Si es true, quita todas las herramientas" } + } + } + }, + { + name: "_webmcp_server-info", + description: "[DEV] Muestra estado del servidor @nucleoriofrio/webmcp: version, commit, host, puerto, canales activos, clientes, registry de tools/prompts/resources, uptime y requests pendientes.", + inputSchema: { + type: "object", + properties: {} + } + } + ); + } + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { tools: builtInTools }; + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error("List tools request timed out")); + } + }, 1e4); + }); + try { + await sendMessage({ + id: requestId, + type: "listTools" + }); + const tools = await responsePromise; + return { tools: [...tools, ...builtInTools] }; + } catch (error2) { + console.error("Error listing tools:", error2); + return { tools: [] }; + } +}); +mcpServer.setRequestHandler(ListPromptsRequestSchema, async () => { + const builtInPrompts = []; + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { + prompts: builtInPrompts + }; + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error("List prompts request timed out")); + } + }, 1e4); + }); + try { + await sendMessage({ + id: requestId, + type: "listPrompts" + }); + const prompts = await responsePromise; + return { + prompts: [ + ...prompts, + ...builtInPrompts + ] + }; + } catch (error2) { + console.error("Error listing prompts:", error2); + return { prompts: [] }; + } +}); +mcpServer.setRequestHandler(GetPromptRequestSchema, async (request) => { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + throw new Error("Not connected to WebSocket server"); + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error(`Get prompt request timed out: ${request.params.name}`)); + } + }, 3e4); + }); + try { + await sendMessage({ + id: requestId, + type: "getPrompt", + name: request.params.name, + arguments: request.params.arguments + }); + return await responsePromise; + } catch (error2) { + console.error("Error getting prompt:", error2); + throw error2; + } +}); +mcpServer.setRequestHandler(ListResourcesRequestSchema, async () => { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { resources: [] }; + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error("List resources request timed out")); + } + }, 1e4); + }); + try { + await sendMessage({ + id: requestId, + type: "listResources" + }); + const { resources } = await responsePromise; + return { resources }; + } catch (error2) { + console.error("Error listing resources:", error2); + return { resources: [] }; + } +}); +mcpServer.setRequestHandler(ListResourceTemplatesRequestSchema, async () => { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + return { resourceTemplates: [] }; + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error("List resource templates request timed out")); + } + }, 1e4); + }); + try { + await sendMessage({ + id: requestId, + type: "listResources" + }); + const { resourceTemplates } = await responsePromise; + return { resourceTemplates }; + } catch (error2) { + console.error("Error listing resource templates:", error2); + return { resourceTemplates: [] }; + } +}); +mcpServer.setRequestHandler(ReadResourceRequestSchema, async (request) => { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + throw new Error("Not connected to WebSocket server"); + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error(`Read resource request timed out: ${request.params.uri}`)); + } + }, 3e4); + }); + try { + await sendMessage({ + id: requestId, + type: "readResource", + uri: request.params.uri + }); + return await responsePromise; + } catch (error2) { + console.error("Error reading resource:", error2); + throw error2; + } +}); +mcpServer.setRequestHandler(CreateMessageRequestSchema, async (request) => { + if (!wsClient || wsClient.readyState !== wrapper_default.OPEN) { + throw new Error("Not connected to WebSocket server"); + } + const requestId = (requestIdCounter++).toString(); + const responsePromise = new Promise((resolve, reject) => { + pendingRequests.set(requestId, { resolve, reject }); + setTimeout(() => { + if (pendingRequests.has(requestId)) { + pendingRequests.delete(requestId); + reject(new Error(`Sampling request timed out`)); + } + }, 12e4); + }); + try { + await sendMessage({ + id: requestId, + type: "createSamplingMessage", + messages: request.params.messages, + systemPrompt: request.params.systemPrompt, + includeContext: request.params.includeContext, + temperature: request.params.temperature, + maxTokens: request.params.maxTokens, + stopSequences: request.params.stopSequences, + metadata: request.params.metadata, + modelPreferences: request.params.modelPreferences + }); + return await responsePromise; + } catch (error2) { + console.error("Error creating sampling message:", error2); + throw error2; + } +}); +async function runMcpServer(serverToken2) { + connectToWebSocketServer(serverToken2); + const transport = new StdioServerTransport(); + await mcpServer.connect(transport); + console.error("@nucleoriofrio/webmcp v0.2.0 \u2014 MCP server running with stdio transport"); + if (CONFIG.dev) { + console.error("[DEV] Modo desarrollo activo \u2014 agregar-tool y quitar-tool habilitados"); + } +} + +// src/websocket-server.js +var serverToken = SERVER_TOKEN; +var httpServer = createServer(async (req, res) => { + res.setHeader("Access-Control-Allow-Origin", "*"); + res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS"); + res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization"); + if (req.method === "OPTIONS") { + res.writeHead(204); + res.end(); + return; + } + const url2 = new URL(`http://${HOST}${req.url}`); + if (url2.pathname === "/token" && req.method === "POST") { + try { + const token = await generateNewRegistrationToken(); + res.writeHead(200, { "Content-Type": "application/json" }); + res.end(JSON.stringify({ + success: true, + token + })); + } catch (error2) { + console.error("Error generating token:", error2); + res.writeHead(500, { "Content-Type": "application/json" }); + res.end(JSON.stringify({ error: "Failed to generate token" })); + } + return; + } + if (url2.pathname === "/status" && req.method === "GET") { + res.writeHead(200, { "Content-Type": "application/json" }); + res.end(JSON.stringify({ + status: "running", + clients: wss.clients.size, + version: "0.2.0" + })); + return; + } + res.writeHead(200, { "Content-Type": "text/plain" }); + res.end("MCP WebSocket server is running"); +}); +var wss = new import_websocket_server.default({ + server: httpServer, + clientTracking: true, + verifyClient: verifyClientToken +}); +var channels = {}; +var clientMetadata = /* @__PURE__ */ new Map(); +var MCP_PATH2 = "/mcp"; +var REGISTER_PATH = "/register"; +function sendNotification(clientWs, channelPath, notificationType, data, mcpOnly = false) { + if (clientWs && clientWs.readyState === import_websocket.default.OPEN) { + if (!mcpOnly) { + clientWs.send(JSON.stringify({ + type: notificationType, + ...data + })); + } + } + if (channels[MCP_PATH2] && channels[MCP_PATH2].size > 0) { + try { + for (const mcpClient of channels[MCP_PATH2]) { + if (mcpClient && mcpClient.readyState === import_websocket.default.OPEN) { + const mcpData = { ...data }; + if (mcpData.name && channelPath) { + mcpData.name = `${channelPath.slice(1)}-${mcpData.name}`; + } + mcpClient.send(JSON.stringify({ + type: notificationType, + ...mcpData + })); + } + } + } catch (e) { + console.error("Error sending notification to MCP:", e.message); + } + } +} +var toolsRegistry = {}; +var promptsRegistry = {}; +var resourcesRegistry = {}; +var serverStartTime = Date.now(); +var gitCommit = "unknown"; +try { + gitCommit = execSync2("git rev-parse --short HEAD", { stdio: ["pipe", "pipe", "ignore"] }).toString().trim(); +} catch (e) { +} +var requestIdCounter2 = 1; +var pendingRequests2 = {}; +async function verifyClientToken(info, callback) { + const url2 = new URL(`https://${HOST}${info.req.url}`); + const clientToken = url2.searchParams.get("token"); + const path3 = url2.pathname || "/"; + if (path3 === MCP_PATH2) { + if (clientToken === process.env.WEBMCP_SERVER_TOKEN) { + return callback(true); + } + console.error("Invalid MCP token provided"); + return callback(false, 401, "Unauthorized - Invalid MCP token"); + } + if (path3 === REGISTER_PATH) { + return callback(true); + } + if (!clientToken) { + console.error("No token provided for path:", path3); + return callback(false, 401, "Unauthorized - No token provided"); + } + await loadAuthorizedTokens(); + if (getToken(path3) === clientToken) { + return callback(true); + } + console.error(`Unauthorized connection attempt to ${path3}`); + return callback(false, 401, "Unauthorized - Invalid channel-token pair"); +} +function getOrCreateChannel(channelPath) { + if (!channels[channelPath]) { + channels[channelPath] = /* @__PURE__ */ new Set(); + console.error(`Created new channel for path: ${channelPath}`); + } else if (channels[channelPath].closeTimeout) { + clearTimeout(channels[channelPath].closeTimeout); + delete channels[channelPath].closeTimeout; + console.error(`Cancelled channel closure for ${channelPath} as a new client connected`); + } + return channels[channelPath]; +} +wss.on("connection", (ws, req) => { + const parsedUrl = parse3(req.url); + const path3 = parsedUrl.pathname; + const clientChannel = path3 || "/"; + console.error(`Client connected from ${req.socket.remoteAddress} to path: ${clientChannel}`); + if (clientChannel === REGISTER_PATH) { + console.error(`Registration request received from ${req.socket.remoteAddress}`); + let registrationTimeout = setTimeout(() => { + console.error("Registration timeout - closing connection"); + ws.close(1008, "Registration timeout"); + }, 3e4); + ws.once("message", async (message) => { + clearTimeout(registrationTimeout); + try { + const encodedData = message.toString(); + const decodedJson = Buffer.from(encodedData, "base64").toString("utf8"); + const connectionData = JSON.parse(decodedJson); + const { host, token } = connectionData; + if (!token) { + console.error("Invalid registration data format - missing token"); + ws.send(JSON.stringify({ + type: "error", + message: "Invalid registration data format - missing token" + })); + ws.close(1008, "Invalid registration data"); + return; + } + const channelPath = formatChannel(host); + if (!token || token.length < 16) { + console.error("Invalid token provided"); + ws.send(JSON.stringify({ + type: "error", + message: "Invalid token provided" + })); + ws.close(1008, "Invalid token"); + return; + } + const serverChannel = formatChannel(`${HOST}:${CONFIG.port}`); + await loadAuthorizedTokens(); + if (token !== getToken(serverChannel)) { + console.error("Invalid token provided"); + ws.send(JSON.stringify({ + type: "error", + message: "Invalid token provided" + })); + ws.close(1008, "Invalid token"); + return; + } + deleteToken(serverChannel); + const sessionToken = generateToken(); + setToken(channelPath, sessionToken); + await saveAuthorizedTokens(); + ws.send(JSON.stringify({ + type: "registerSuccess", + channel: channelPath, + message: `Registration successful for ${channelPath}`, + token: sessionToken + })); + console.error(`Registered channel: ${channelPath} with token: ${token}`); + ws.close(1e3, "Registration complete"); + } catch (error2) { + console.error("Registration error:", error2); + ws.send(JSON.stringify({ + type: "error", + message: "Registration error" + })); + ws.close(1011, "Registration error"); + } + }); + return; + } + const channel = getOrCreateChannel(clientChannel); + channel.add(ws); + ws.send(JSON.stringify({ + type: "welcome", + channel: clientChannel, + message: `Connected to path: ${clientChannel}` + })); + ws.on("message", (message) => { + try { + const data = JSON.parse(message); + console.error(`Received message: ${data.type} on ${clientChannel}`); + switch (data.type) { + case "ping": + handlePing(ws, data); + break; + case "registerTool": + handleRegisterTool(ws, clientChannel, data); + break; + case "registerPrompt": + handleRegisterPrompt(ws, clientChannel, data); + break; + case "registerResource": + handleRegisterResource(ws, clientChannel, data); + break; + case "unregisterTool": + handleUnregisterTool(ws, clientChannel, data); + break; + case "unregisterPrompt": + handleUnregisterPrompt(ws, clientChannel, data); + break; + case "unregisterResource": + handleUnregisterResource(ws, clientChannel, data); + break; + case "unregisterAllTools": + handleUnregisterAllTools(ws, clientChannel); + break; + case "listTools": + handleListTools(ws, clientChannel, data); + break; + case "listPrompts": + handleListPrompts(ws, clientChannel, data); + break; + case "listResources": + handleListResources(ws, clientChannel, data); + break; + case "callTool": + handleCallTool(ws, clientChannel, data); + break; + case "getPrompt": + handleGetPrompt(ws, clientChannel, data); + break; + case "readResource": + handleReadResource(ws, clientChannel, data); + break; + case "createSamplingMessage": + handleCreateSamplingMessage(ws, clientChannel, data); + break; + case "toolResponse": + handleToolResponse(data); + break; + case "promptResponse": + handlePromptResponse(data); + break; + case "resourceResponse": + handleResourceResponse(data); + break; + case "samplingResponse": + handleSamplingResponse(data); + break; + case "clipboardCopy": + handleClipboardCopy(data); + break; + case "clientInfo": + handleClientInfo(ws, data); + break; + case "clientInfoResponse": + handleToolResponse(data); + break; + case "getClientInfo": + handleGetClientInfo(ws, clientChannel, data); + break; + case "getServerInfo": + handleGetServerInfo(ws, data); + break; + case "clearRegistry": + handleClearRegistry(ws, data); + break; + case "createTool": + handleCreateTool(ws, data); + break; + case "removeTool": + handleRemoveTool(ws, data); + break; + default: + ws.send(JSON.stringify({ + type: "error", + message: `Unknown message type: ${data.type}` + })); + } + } catch (error2) { + const msgPreview = typeof message === "string" ? message.slice(0, 200) : String(message).slice(0, 200); + console.error(`Error processing WebSocket message on ${clientChannel}:`, error2.message, "\nRaw message preview:", msgPreview); + try { + ws.send(JSON.stringify({ + type: "error", + message: `Error: ${error2.message}` + })); + } catch (sendError) { + console.error("Error sending error response:", sendError); + } + } + }); + ws.on("close", async () => { + console.error(`Client disconnected from path: ${clientChannel}`); + clientMetadata.delete(ws); + const channel2 = channels[clientChannel]; + if (channel2) { + channel2.delete(ws); + if (channel2.size === 0) { + console.error(`Channel ${clientChannel} is empty, will close in 1 minute if no one joins`); + channel2.closeTimeout = setTimeout(async () => { + if (channels[clientChannel] && channels[clientChannel].size === 0) { + delete channels[clientChannel]; + console.error(`Removed empty channel for path: ${clientChannel} after 1 minute inactivity`); + const itemsToRemove = { + tools: [], + prompts: [], + resources: [] + }; + for (const [toolId, toolInfo] of Object.entries(toolsRegistry)) { + if (toolInfo.channel === clientChannel) { + itemsToRemove.tools.push(toolId); + } + } + for (const [promptId, promptInfo] of Object.entries(promptsRegistry)) { + if (promptInfo.channel === clientChannel) { + itemsToRemove.prompts.push(promptId); + } + } + for (const [resourceId, resourceInfo] of Object.entries(resourcesRegistry)) { + if (resourceInfo.channel === clientChannel) { + itemsToRemove.resources.push(resourceId); + } + } + itemsToRemove.tools.forEach((toolId) => { + delete toolsRegistry[toolId]; + console.error(`Removed tool: ${toolId} from path: ${clientChannel}`); + }); + itemsToRemove.prompts.forEach((promptId) => { + delete promptsRegistry[promptId]; + console.error(`Removed prompt: ${promptId} from path: ${clientChannel}`); + }); + itemsToRemove.resources.forEach((resourceId) => { + delete resourcesRegistry[resourceId]; + console.error(`Removed resource: ${resourceId} from path: ${clientChannel}`); + }); + if (clientChannel !== MCP_PATH2) { + deleteToken(clientChannel); + await saveAuthorizedTokens(); + console.error(`Removed authorized token for channel: ${clientChannel}`); + } + sendNotification(ws, void 0, "toolRegistered", {}, true); + sendNotification(ws, void 0, "promptRegistered", {}, true); + sendNotification(ws, void 0, "resourceRegistered", {}, true); + } + }, 6e4); + } + } + }); + ws.on("error", (error2) => { + console.error("WebSocket error:", error2); + clientMetadata.delete(ws); + const channel2 = channels[clientChannel]; + if (channel2) { + channel2.delete(ws); + } + }); +}); +function handlePing(ws, data) { + ws.send(JSON.stringify({ + id: data.id, + type: "pong", + timestamp: Date.now() + })); +} +function handleRegisterTool(ws, channelPath, data) { + const { name, description, inputSchema } = data; + if (!name) { + ws.send(JSON.stringify({ + type: "error", + message: "Tool name is required" + })); + return; + } + const toolId = `${channelPath.slice(1)}-${name}`; + toolsRegistry[toolId] = { + channel: channelPath, + name, + description: description || `Tool: ${name}`, + inputSchema, + originalName: name + }; + sendNotification(ws, channelPath, "toolRegistered", { + name, + toolId + }); + console.error(`Tool registered: ${toolId}`); +} +function handleRegisterPrompt(ws, channelPath, data) { + const { name, description, arguments: promptArgs } = data; + if (!name) { + ws.send(JSON.stringify({ + type: "error", + message: "Prompt name is required" + })); + return; + } + const promptId = `${channelPath.slice(1)}-${name}`; + promptsRegistry[promptId] = { + channel: channelPath, + name, + description: description || `Prompt: ${name}`, + arguments: promptArgs || [], + originalName: name + }; + sendNotification(ws, channelPath, "promptRegistered", { + name, + promptId + }); + console.error(`Prompt registered: ${promptId}`); +} +function handleRegisterResource(ws, channelPath, data) { + const { uri, name, description, mimeType, isTemplate, uriTemplate } = data; + if (!uri && !uriTemplate || !name) { + ws.send(JSON.stringify({ + type: "error", + message: "Resource URI/template and name are required" + })); + return; + } + const resourceId = `${channelPath.slice(1)}-${name}`; + resourcesRegistry[resourceId] = { + channel: channelPath, + name, + description: description || `Resource: ${name}`, + uri, + uriTemplate, + isTemplate: !!isTemplate, + mimeType, + originalName: name + }; + sendNotification(ws, channelPath, "resourceRegistered", { + name, + resourceId + }); + console.error(`Resource registered: ${resourceId}`); +} +function handleUnregisterTool(ws, channelPath, data) { + const { name } = data; + if (!name) { + ws.send(JSON.stringify({ + type: "error", + message: "Tool name is required" + })); + return; + } + const toolId = `${channelPath.slice(1)}-${name}`; + if (!toolsRegistry[toolId]) { + ws.send(JSON.stringify({ + type: "error", + message: `Tool not found: ${name}` + })); + return; + } + delete toolsRegistry[toolId]; + sendNotification(ws, channelPath, "toolRegistered", { + name, + toolId + }); + console.error(`Tool unregistered: ${toolId}`); +} +function handleUnregisterPrompt(ws, channelPath, data) { + const { name } = data; + if (!name) { + ws.send(JSON.stringify({ + type: "error", + message: "Prompt name is required" + })); + return; + } + const promptId = `${channelPath.slice(1)}-${name}`; + if (!promptsRegistry[promptId]) { + ws.send(JSON.stringify({ + type: "error", + message: `Prompt not found: ${name}` + })); + return; + } + delete promptsRegistry[promptId]; + sendNotification(ws, channelPath, "promptRegistered", { + name, + promptId + }); + console.error(`Prompt unregistered: ${promptId}`); +} +function handleUnregisterResource(ws, channelPath, data) { + const { name } = data; + if (!name) { + ws.send(JSON.stringify({ + type: "error", + message: "Resource name is required" + })); + return; + } + const resourceId = `${channelPath.slice(1)}-${name}`; + if (!resourcesRegistry[resourceId]) { + ws.send(JSON.stringify({ + type: "error", + message: `Resource not found: ${name}` + })); + return; + } + delete resourcesRegistry[resourceId]; + sendNotification(ws, channelPath, "resourceRegistered", { + name, + resourceId + }); + console.error(`Resource unregistered: ${resourceId}`); +} +function handleUnregisterAllTools(ws, channelPath) { + const removed = []; + for (const [toolId, toolInfo] of Object.entries(toolsRegistry)) { + if (toolInfo.channel === channelPath) { + removed.push(toolId); + } + } + removed.forEach((toolId) => { + delete toolsRegistry[toolId]; + }); + if (removed.length > 0) { + sendNotification(ws, channelPath, "toolRegistered", {}, true); + console.error(`Batch unregistered ${removed.length} tools from ${channelPath}`); + } +} +function handleCreateTool(ws, data) { + const { id, name, description, code, parametros } = data; + let targetClient = null; + let targetChannel = null; + for (const [channelPath, clients] of Object.entries(channels)) { + if (channelPath === MCP_PATH2) continue; + if (clients.size > 0) { + targetClient = clients.values().next().value; + targetChannel = channelPath; + break; + } + } + if (!targetClient) { + ws.send(JSON.stringify({ + id, + type: "toolResponse", + error: "No hay navegadores conectados para crear la herramienta" + })); + return; + } + const requestId = (requestIdCounter2++).toString(); + pendingRequests2[requestId] = { originalId: id, requesterWs: ws, timestamp: Date.now() }; + setTimeout(() => { + if (pendingRequests2[requestId]) { + const { requesterWs, originalId } = pendingRequests2[requestId]; + delete pendingRequests2[requestId]; + try { + requesterWs.send(JSON.stringify({ id: originalId, type: "toolResponse", error: "Timeout creando herramienta" })); + } catch (e) { + } + } + }, 15e3); + targetClient.send(JSON.stringify({ + id: requestId, + type: "createTool", + name, + description, + code, + parametros + })); + console.error(`createTool forwarded to ${targetChannel}: ${name}`); +} +function handleRemoveTool(ws, data) { + const { id, name, listar, todas } = data; + if (listar) { + const tools = Object.entries(toolsRegistry).filter(([_, info]) => info.channel !== MCP_PATH2).map(([toolId, info]) => info.originalName); + const msg = tools.length > 0 ? `Herramientas activas: ${tools.join(", ")}` : "No hay herramientas registradas"; + ws.send(JSON.stringify({ id, type: "toolResponse", result: { content: [{ type: "text", text: msg }] } })); + return; + } + if (todas) { + let count = 0; + for (const [toolId, info] of Object.entries(toolsRegistry)) { + if (info.channel !== MCP_PATH2) { + delete toolsRegistry[toolId]; + count++; + } + } + for (const [channelPath, clients] of Object.entries(channels)) { + if (channelPath === MCP_PATH2) continue; + clients.forEach((c) => { + if (c.readyState === import_websocket.default.OPEN) { + c.send(JSON.stringify({ type: "removeAllTools" })); + } + }); + } + ws.send(JSON.stringify({ id, type: "toolResponse", result: { content: [{ type: "text", text: `${count} herramientas desregistradas` }] } })); + return; + } + if (!name) { + ws.send(JSON.stringify({ id, type: "toolResponse", error: "Especifica nombre, listar=true, o todas=true" })); + return; + } + let found = false; + for (const [toolId, info] of Object.entries(toolsRegistry)) { + if (info.originalName === name) { + const channel = info.channel; + delete toolsRegistry[toolId]; + found = true; + if (channels[channel]) { + channels[channel].forEach((c) => { + if (c.readyState === import_websocket.default.OPEN) { + c.send(JSON.stringify({ type: "removeTool", name })); + } + }); + } + break; + } + } + if (found) { + ws.send(JSON.stringify({ id, type: "toolResponse", result: { content: [{ type: "text", text: `Herramienta "${name}" desregistrada` }] } })); + } else { + ws.send(JSON.stringify({ id, type: "toolResponse", error: `Herramienta "${name}" no encontrada` })); + } +} +function handleClientInfo(ws, data) { + const { userAgent, url: url2, hostname: hostname3, language, screenWidth, screenHeight, timestamp } = data; + clientMetadata.set(ws, { userAgent, url: url2, hostname: hostname3, language, screenWidth, screenHeight, timestamp }); + console.error(`Client info stored for ${hostname3}: ${url2}`); +} +function handleGetClientInfo(ws, callerChannel, data) { + const { id } = data; + const clients = []; + for (const [channelPath, channelClients] of Object.entries(channels)) { + if (channelPath === MCP_PATH2 || channelPath === REGISTER_PATH) continue; + for (const clientWs of channelClients) { + const meta3 = clientMetadata.get(clientWs) || {}; + clients.push({ + channel: channelPath, + userAgent: meta3.userAgent || "unknown", + url: meta3.url || "unknown", + hostname: meta3.hostname || "unknown", + language: meta3.language || "unknown", + screenWidth: meta3.screenWidth || 0, + screenHeight: meta3.screenHeight || 0, + connectedSince: meta3.timestamp || 0 + }); + } + } + const text = clients.length > 0 ? JSON.stringify(clients, null, 2) : "No hay navegadores conectados"; + ws.send(JSON.stringify({ + id, + type: "toolResponse", + result: { content: [{ type: "text", text }] } + })); +} +function handleGetServerInfo(ws, data) { + const { id } = data; + const uptimeMs = Date.now() - serverStartTime; + const uptimeSec = Math.floor(uptimeMs / 1e3); + const hours = Math.floor(uptimeSec / 3600); + const minutes = Math.floor(uptimeSec % 3600 / 60); + const seconds = uptimeSec % 60; + const channelsList = {}; + for (const [channelPath, channelClients] of Object.entries(channels)) { + channelsList[channelPath] = channelClients.size; + } + const info = { + server: `@nucleoriofrio/webmcp v0.2.0`, + commit: gitCommit, + host: HOST, + port: CONFIG.port, + dev: !!CONFIG.dev, + uptime: `${hours}h ${minutes}m ${seconds}s`, + uptimeMs, + channels: channelsList, + totalClients: Object.values(channels).reduce((sum, ch) => sum + ch.size, 0), + registry: { + tools: Object.keys(toolsRegistry).length, + prompts: Object.keys(promptsRegistry).length, + resources: Object.keys(resourcesRegistry).length + }, + toolsList: Object.entries(toolsRegistry).map(([id2, info2]) => ({ + id: id2, + name: info2.originalName, + channel: info2.channel + })), + pendingRequests: Object.keys(pendingRequests2).length + }; + ws.send(JSON.stringify({ + id, + type: "toolResponse", + result: { content: [{ type: "text", text: JSON.stringify(info, null, 2) }] } + })); +} +function handleClearRegistry(ws, data) { + const { id } = data; + let toolCount = Object.keys(toolsRegistry).length; + let promptCount = Object.keys(promptsRegistry).length; + let resourceCount = Object.keys(resourcesRegistry).length; + for (const key of Object.keys(toolsRegistry)) delete toolsRegistry[key]; + for (const key of Object.keys(promptsRegistry)) delete promptsRegistry[key]; + for (const key of Object.keys(resourcesRegistry)) delete resourcesRegistry[key]; + const msg = `Cache limpiado: ${toolCount} tools, ${promptCount} prompts, ${resourceCount} resources eliminados`; + console.error(msg); + ws.send(JSON.stringify({ + id, + type: "toolResponse", + result: msg + })); +} +function handleClipboardCopy(data) { + const { text } = data; + if (!text) return; + for (const [channelPath, channelClients] of Object.entries(channels)) { + if (channelPath === MCP_PATH2) continue; + channelClients.forEach((client) => { + if (client.readyState === import_websocket.default.OPEN) { + client.send(JSON.stringify({ + type: "clipboardCopy", + text + })); + } + }); + } + console.error(`Clipboard copy broadcasted to web clients`); +} +function handleListTools(ws, clientChannel, data) { + const { id } = data; + const isMcpClient = clientChannel === MCP_PATH2; + let tools; + if (isMcpClient) { + tools = Object.entries(toolsRegistry).map(([toolId, toolInfo]) => { + const pathBasedName = `${toolInfo.channel.slice(1)}-${toolInfo.originalName}`; + return { + name: pathBasedName, + description: toolInfo.description, + inputSchema: toolInfo.inputSchema + }; + }); + console.error(`Sending all ${tools.length} tools to MCP client on path ${clientChannel}`); + } else { + tools = Object.entries(toolsRegistry).filter(([_, toolInfo]) => toolInfo.channel === clientChannel).map(([_, toolInfo]) => ({ + name: toolInfo.originalName, + description: toolInfo.description, + inputSchema: toolInfo.inputSchema + })); + console.error(`Sending ${tools.length} tools from path ${clientChannel}`); + } + ws.send(JSON.stringify({ + id, + type: "listToolsResponse", + tools + })); +} +function handleListPrompts(ws, clientChannel, data) { + const { id } = data; + const isMcpClient = clientChannel === MCP_PATH2; + let prompts; + if (isMcpClient) { + prompts = Object.entries(promptsRegistry).map(([promptId, promptInfo]) => { + const pathBasedName = `${promptInfo.channel.slice(1)}-${promptInfo.originalName}`; + return { + name: pathBasedName, + description: promptInfo.description, + arguments: promptInfo.arguments + }; + }); + console.error(`Sending all ${prompts.length} prompts to MCP client on path ${clientChannel}`); + } else { + prompts = Object.entries(promptsRegistry).filter(([_, promptInfo]) => promptInfo.channel === clientChannel).map(([_, promptInfo]) => ({ + name: promptInfo.originalName, + description: promptInfo.description, + arguments: promptInfo.arguments + })); + console.error(`Sending ${prompts.length} prompts from path ${clientChannel}`); + } + ws.send(JSON.stringify({ + id, + type: "listPromptsResponse", + prompts + })); +} +function handleListResources(ws, clientChannel, data) { + const { id } = data; + const isMcpClient = clientChannel === MCP_PATH2; + let resources = []; + let resourceTemplates = []; + if (isMcpClient) { + Object.entries(resourcesRegistry).forEach(([resourceId, resourceInfo]) => { + const pathBasedName = `${resourceInfo.channel.slice(1)}-${resourceInfo.originalName}`; + if (resourceInfo.isTemplate) { + resourceTemplates.push({ + name: pathBasedName, + description: resourceInfo.description, + uriTemplate: resourceInfo.uriTemplate, + mimeType: resourceInfo.mimeType + }); + } else { + resources.push({ + name: pathBasedName, + description: resourceInfo.description, + uri: resourceInfo.uri, + mimeType: resourceInfo.mimeType + }); + } + }); + console.error(`Sending all ${resources.length} resources and ${resourceTemplates.length} templates to MCP client on path ${clientChannel}`); + } else { + Object.entries(resourcesRegistry).filter(([_, resourceInfo]) => resourceInfo.channel === clientChannel).forEach(([_, resourceInfo]) => { + if (resourceInfo.isTemplate) { + resourceTemplates.push({ + name: resourceInfo.originalName, + description: resourceInfo.description, + uriTemplate: resourceInfo.uriTemplate, + mimeType: resourceInfo.mimeType + }); + } else { + resources.push({ + name: resourceInfo.originalName, + description: resourceInfo.description, + uri: resourceInfo.uri, + mimeType: resourceInfo.mimeType + }); + } + }); + console.error(`Sending ${resources.length} resources and ${resourceTemplates.length} templates from path ${clientChannel}`); + } + ws.send(JSON.stringify({ + id, + type: "listResourcesResponse", + resources, + resourceTemplates + })); +} +function handleCallTool(ws, callerChannel, data) { + const { id, tool, arguments: args } = data; + const isMcpClient = callerChannel === MCP_PATH2; + let targetChannel; + let toolName; + if (isMcpClient && tool.startsWith("/")) { + [targetChannel, toolName] = tool.slice(1).split("-").slice(1); + targetChannel = `/${targetChannel}`; + } else { + if (!toolsRegistry[tool]) { + ws.send(JSON.stringify({ + id, + type: "toolResponse", + error: `Tool not found: ${tool}` + })); + return; + } + const toolInfo = toolsRegistry[tool]; + targetChannel = toolInfo.channel; + toolName = toolInfo.originalName; + } + if (!channels[targetChannel] || channels[targetChannel].size === 0) { + ws.send(JSON.stringify({ + id, + type: "toolResponse", + error: `No clients available in channel ${targetChannel} to handle tool: ${toolName}` + })); + return; + } + const targetClient = channels[targetChannel].values().next().value; + const requestId = (requestIdCounter2++).toString(); + pendingRequests2[requestId] = { + originalId: id, + requesterWs: ws, + timestamp: Date.now() + }; + setTimeout(() => { + if (pendingRequests2[requestId]) { + const { requesterWs, originalId } = pendingRequests2[requestId]; + delete pendingRequests2[requestId]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "toolResponse", + error: `Tool call timed out: ${toolName}` + })); + } catch (error2) { + console.error("Error sending timeout response:", error2); + } + } + }, 3e4); + targetClient.send(JSON.stringify({ + id: requestId, + type: "callTool", + tool: toolName, + // Send just the tool name without channel prefix + arguments: args + })); + console.error(`Tool call forwarded: ${toolName} to channel: ${targetChannel}`); +} +function handleGetPrompt(ws, callerChannel, data) { + const { id, name, arguments: args } = data; + const isMcpClient = callerChannel === MCP_PATH2; + let targetChannel; + let promptName; + if (isMcpClient && name.startsWith("/")) { + [targetChannel, promptName] = name.slice(1).split("-").slice(1); + targetChannel = `/${targetChannel}`; + } else { + const promptInfo = Object.values(promptsRegistry).find((p) => p.channel === callerChannel && p.originalName === name); + if (!promptInfo) { + ws.send(JSON.stringify({ + id, + type: "promptResponse", + error: `Prompt not found: ${name}` + })); + return; + } + targetChannel = promptInfo.channel; + promptName = promptInfo.originalName; + } + if (!channels[targetChannel] || channels[targetChannel].size === 0) { + ws.send(JSON.stringify({ + id, + type: "promptResponse", + error: `No clients available in channel ${targetChannel} to handle prompt: ${promptName}` + })); + return; + } + const targetClient = channels[targetChannel].values().next().value; + const requestId = (requestIdCounter2++).toString(); + pendingRequests2[requestId] = { + originalId: id, + requesterWs: ws, + timestamp: Date.now() + }; + setTimeout(() => { + if (pendingRequests2[requestId]) { + const { requesterWs, originalId } = pendingRequests2[requestId]; + delete pendingRequests2[requestId]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "promptResponse", + error: `Prompt request timed out: ${promptName}` + })); + } catch (error2) { + console.error("Error sending timeout response:", error2); + } + } + }, 3e4); + targetClient.send(JSON.stringify({ + id: requestId, + type: "getPrompt", + name: promptName, + arguments: args + })); + console.error(`Prompt request forwarded: ${promptName} to channel: ${targetChannel}`); +} +function handleReadResource(ws, callerChannel, data) { + const { id, uri } = data; + let targetChannel; + let resourceName; + let resourceInfo; + for (const [resId, info] of Object.entries(resourcesRegistry)) { + if (!info.isTemplate && info.uri === uri) { + resourceInfo = info; + targetChannel = info.channel; + resourceName = info.originalName; + break; + } + } + if (!resourceInfo) { + for (const [resId, info] of Object.entries(resourcesRegistry)) { + if (info.isTemplate && uri.startsWith(info.uriTemplate.split("{")[0])) { + resourceInfo = info; + targetChannel = info.channel; + resourceName = info.originalName; + break; + } + } + } + if (!resourceInfo) { + ws.send(JSON.stringify({ + id, + type: "resourceResponse", + error: `Resource not found for URI: ${uri}` + })); + return; + } + if (!channels[targetChannel] || channels[targetChannel].size === 0) { + ws.send(JSON.stringify({ + id, + type: "resourceResponse", + error: `No clients available in channel ${targetChannel} to handle resource: ${resourceName}` + })); + return; + } + const targetClient = channels[targetChannel].values().next().value; + const requestId = (requestIdCounter2++).toString(); + pendingRequests2[requestId] = { + originalId: id, + requesterWs: ws, + timestamp: Date.now() + }; + setTimeout(() => { + if (pendingRequests2[requestId]) { + const { requesterWs, originalId } = pendingRequests2[requestId]; + delete pendingRequests2[requestId]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "resourceResponse", + error: `Resource request timed out: ${uri}` + })); + } catch (error2) { + console.error("Error sending timeout response:", error2); + } + } + }, 3e4); + targetClient.send(JSON.stringify({ + id: requestId, + type: "readResource", + uri + })); + console.error(`Resource request forwarded: ${uri} to channel: ${targetChannel}`); +} +function handleToolResponse(data) { + const { id, result, error: error2 } = data; + if (!pendingRequests2[id]) { + console.error(`No pending request found for ID: ${id}`); + return; + } + const { requesterWs, originalId } = pendingRequests2[id]; + delete pendingRequests2[id]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "toolResponse", + result, + error: error2 + })); + } catch (error3) { + console.error("Error forwarding tool response:", error3); + } +} +function handlePromptResponse(data) { + const { id, result, error: error2 } = data; + if (!pendingRequests2[id]) { + console.error(`No pending request found for ID: ${id}`); + return; + } + const { requesterWs, originalId } = pendingRequests2[id]; + delete pendingRequests2[id]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "promptResponse", + result, + error: error2 + })); + } catch (error3) { + console.error("Error forwarding prompt response:", error3); + } +} +function handleResourceResponse(data) { + const { id, result, error: error2 } = data; + if (!pendingRequests2[id]) { + console.error(`No pending request found for ID: ${id}`); + return; + } + const { requesterWs, originalId } = pendingRequests2[id]; + delete pendingRequests2[id]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "resourceResponse", + result, + error: error2 + })); + } catch (error3) { + console.error("Error forwarding resource response:", error3); + } +} +function handleSamplingResponse(data) { + const { id, result, error: error2 } = data; + if (!pendingRequests2[id]) { + console.error(`No pending request found for ID: ${id}`); + return; + } + const { requesterWs, originalId } = pendingRequests2[id]; + delete pendingRequests2[id]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "samplingResponse", + result, + error: error2 + })); + } catch (error3) { + console.error("Error forwarding sampling response:", error3); + } +} +function handleCreateSamplingMessage(ws, callerChannel, data) { + const { + id, + messages, + systemPrompt, + includeContext, + temperature, + maxTokens, + stopSequences, + metadata, + modelPreferences + } = data; + const isMcpClient = callerChannel === MCP_PATH2; + if (!isMcpClient) { + ws.send(JSON.stringify({ + id, + type: "samplingResponse", + error: `Sampling is only available through MCP path` + })); + return; + } + let targetClient = null; + let targetChannel = null; + for (const [channel, clients] of Object.entries(channels)) { + if (channel !== MCP_PATH2 && clients.size > 0) { + targetClient = clients.values().next().value; + targetChannel = channel; + break; + } + } + if (!targetClient) { + ws.send(JSON.stringify({ + id, + type: "samplingResponse", + error: "No clients available to handle sampling request" + })); + return; + } + const requestId = (requestIdCounter2++).toString(); + pendingRequests2[requestId] = { + originalId: id, + requesterWs: ws, + timestamp: Date.now() + }; + setTimeout(() => { + if (pendingRequests2[requestId]) { + const { requesterWs, originalId } = pendingRequests2[requestId]; + delete pendingRequests2[requestId]; + try { + requesterWs.send(JSON.stringify({ + id: originalId, + type: "samplingResponse", + error: "Sampling request timed out" + })); + } catch (error2) { + console.error("Error sending timeout response:", error2); + } + } + }, 12e4); + targetClient.send(JSON.stringify({ + id: requestId, + type: "createSamplingMessage", + messages, + systemPrompt, + includeContext, + temperature, + maxTokens, + stopSequences, + metadata, + modelPreferences + })); + console.error(`Sampling request forwarded to channel: ${targetChannel}`); +} +async function isServerRunning() { + if (CONFIG.startMCP && CONFIG.docker) { + return true; + } + try { + const pidData = await fs3.readFile(PID_FILE, "utf8"); + const pid = parseInt(pidData.trim(), 10); + try { + process.kill(pid, 0); + return { running: true, pid }; + } catch (e) { + await fs3.unlink(PID_FILE); + return { running: false }; + } + } catch (error2) { + return { running: false }; + } +} +async function savePid() { + try { + await fs3.writeFile(PID_FILE, process.pid.toString(), "utf8"); + return true; + } catch (error2) { + console.error("Error saving PID file:", error2); + return false; + } +} +async function daemonize() { + const args = process.argv.slice(2); + if (!args.includes("--forked")) { + args.push("--forked"); + } + const child = fork(process.argv[1], args, { + detached: true, + stdio: "ignore" + }); + child.unref(); + console.error(`Server started as daemon with PID: ${child.pid}`); + console.error(`Use 'node websocket-server.js --quit' to stop the server`); + console.error(`Use 'node websocket-server.js --new ' to authorize a channel-token pair`); + console.error(`Put 'npx @nucleoriofrio/webmcp --mcp' in your mcp client config`); + if (!CONFIG.startMCP) { + process.exit(0); + } +} +var parseArgs = async () => { + const args = process.argv.slice(2); + let port = 4797; + let quit = false; + let newToken = false; + let startMCP = false; + let docker = false; + let cleanTokens = false; + let encodedPair = null; + let daemon = true; + let dev = process.env.WEBMCP_DEV === "true" || process.env.WEBMCP_DEV === "1"; + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + if (arg === "-h" || arg === "--help") { + showHelp(); + process.exit(0); + } else if (arg === "-p" || arg === "--port") { + if (i + 1 < args.length) { + const portArg = parseInt(args[i + 1], 10); + if (isNaN(portArg) || portArg < 1 || portArg > 65535) { + console.error("Error: Port must be a number between 1 and 65535"); + showHelp(); + process.exit(1); + } + port = portArg; + i++; + } else { + console.error("Error: Port option requires a value"); + showHelp(); + process.exit(1); + } + } else if (arg === "--config") { + if (i + 1 < args.length) { + const config3 = args[i + 1]; + await configureMcpClient(config3); + i++; + } else { + console.error("Error: Config option requires a mcp client type or path to json"); + showHelp(); + process.exit(1); + } + } else if (arg === "-q" || arg === "--quit") { + quit = true; + } else if (arg === "-n" || arg === "--new") { + newToken = true; + } else if (arg === "-m" || arg === "--mcp") { + startMCP = true; + } else if (arg === "-d" || arg === "--docker") { + docker = true; + } else if (arg === "-c" || arg === "--clean") { + cleanTokens = true; + } else if (arg === "-f" || arg === "--foreground") { + daemon = false; + } else if (arg === "--dev") { + dev = true; + } else if (arg === "--forked") { + } else { + console.error(`Error: Unknown option: ${arg}`); + showHelp(); + process.exit(1); + } + } + return { port, quit, newToken, cleanTokens, encodedPair, daemon, startMCP, dev }; +}; +var showHelp = () => { + console.log(` +Usage: node websocket-server.js [options] + +Options: + --config Automatically update MCP client configuration to add WebMCP + -p, --port Specify the port number (default: 4797) + -h, --help Display this help message + -q, --quit Stop the running server + -n, --new Generate a new token for client registration + -c, --clean Remove all authorized tokens + -f, --foreground Run in foreground (don't daemonize) + -m, --mcp Internal WebMCP Server codepath, likely only used in MCP client config + -d, --docker Tell the MCP client that WebMCP is running in docker + --dev Enable development mode (agregar-tool, quitar-tool) + +Use --new to generate a token which clients can use to register on the /register endpoint. +Use --clean to remove all authorized tokens when you want to start fresh. + `); +}; +var main = async () => { + await ensureConfigDir(); + await loadAuthorizedTokens(); + setConfig(await parseArgs()); + const serverStatus = await isServerRunning(); + if (CONFIG.cleanTokens) { + console.log(`Removing all authorized tokens...`); + clearTokens(); + await saveAuthorizedTokens(); + console.log(`All tokens have been removed. Tokens file cleared.`); + if (serverStatus.running) { + console.log(`Server is running with PID: ${serverStatus.pid}. Please restart it to apply changes.`); + } + process.exit(0); + } + if (CONFIG.quit) { + if (serverStatus.running) { + console.log(`Stopping server with PID: ${serverStatus.pid}`); + try { + process.kill(serverStatus.pid, "SIGTERM"); + console.log("Server stopped successfully"); + } catch (error2) { + console.error("Error stopping server:", error2); + } + } else { + console.log("No running server found"); + } + process.exit(0); + } + if (CONFIG.newToken) { + const encodedData = await generateNewRegistrationToken(); + console.log(` +CONNECTION TOKEN (paste this in your web client):`); + console.log(`${encodedData} +`); + if (serverStatus.running) { + process.exit(0); + } + } + if (!serverToken) { + serverToken = generateToken(); + await saveServerTokenToEnv(serverToken); + } + if (serverStatus.running) { + console.error(`Server is already running with PID: ${serverStatus.pid}`); + console.error(`Use 'node websocket-server.js --quit' to stop the server`); + console.error(`Use 'node websocket-server.js --new ' to authorize a channel-token pair`); + console.error(`Put 'npx @nucleoriofrio/webmcp --mcp' in your mcp client config`); + if (CONFIG.startMCP) { + return; + } else { + process.exit(0); + } + } + if (CONFIG.daemon) { + if (!process.argv.includes("--forked")) { + process.argv.push("--forked"); + return daemonize(); + } + } + await savePid(); + const PORT = CONFIG.port; + httpServer.listen(PORT, () => { + console.error(`@nucleoriofrio/webmcp v0.2.0 \u2014 WebSocket server running at http://${HOST}:${PORT}`); + console.error(`WebMCP client token (for MCP path): ${serverToken}`); + console.error(`WebMCP client URL: ws://${HOST}:${PORT}${MCP_PATH2}?token=${serverToken}`); + if (CONFIG.dev) { + console.error(`[DEV] Modo desarrollo activo \u2014 agregar-tool y quitar-tool habilitados`); + } + console.error(`Use 'node websocket-server.js --new ' to authorize a channel-token pair`); + }); + const shutdownGracefully = async (signal) => { + console.error(` +Received ${signal}. Shutting down gracefully...`); + await saveAuthorizedTokens(); + for (const channel of Object.values(channels)) { + for (const ws of channel) { + try { + ws.close(); + } catch (error2) { + console.error("Error closing WebSocket connection:", error2); + } + } + } + httpServer.close(() => { + console.error("HTTP server closed"); + fs3.unlink(PID_FILE).catch((err) => { + console.error("Error removing PID file:", err); + }); + process.exit(0); + }); + }; + process.on("SIGINT", () => shutdownGracefully("SIGINT")); + process.on("SIGTERM", () => shutdownGracefully("SIGTERM")); + if (process.platform === "win32" && process.stdin.isTTY) { + try { + process.stdin.setRawMode(true); + process.stdin.resume(); + process.stdin.on("data", (data) => { + if (data.length === 1 && data[0] === 3) { + shutdownGracefully("CTRL+C"); + } + }); + } catch (e) { + } + } +}; +main().catch((error2) => { + console.error("Error in main:", error2); + process.exit(1); +}).then(() => { + if (CONFIG.startMCP) { + setTimeout(() => { + console.error("Starting up MCP Server"); + runMcpServer(serverToken).catch((error2) => { + console.error("Fatal error in main():", error2); + process.exit(1); + }); + }, 100); + } +}); +//# sourceMappingURL=index.js.map diff --git a/build/index.js.map b/build/index.js.map new file mode 100644 index 0000000..aa4fbf8 --- /dev/null +++ b/build/index.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../node_modules/ws/lib/constants.js", "../node_modules/ws/lib/buffer-util.js", "../node_modules/ws/lib/limiter.js", "../node_modules/ws/lib/permessage-deflate.js", "../node_modules/ws/lib/validation.js", "../node_modules/ws/lib/receiver.js", "../node_modules/ws/lib/sender.js", "../node_modules/ws/lib/event-target.js", "../node_modules/ws/lib/extension.js", "../node_modules/ws/lib/websocket.js", "../node_modules/ws/lib/stream.js", "../node_modules/ws/lib/subprotocol.js", "../node_modules/ws/lib/websocket-server.js", "../node_modules/ajv/lib/compile/codegen/code.ts", "../node_modules/ajv/lib/compile/codegen/scope.ts", "../node_modules/ajv/lib/compile/codegen/index.ts", "../node_modules/ajv/lib/compile/util.ts", "../node_modules/ajv/lib/compile/names.ts", "../node_modules/ajv/lib/compile/errors.ts", "../node_modules/ajv/lib/compile/validate/boolSchema.ts", "../node_modules/ajv/lib/compile/rules.ts", "../node_modules/ajv/lib/compile/validate/applicability.ts", "../node_modules/ajv/lib/compile/validate/dataType.ts", "../node_modules/ajv/lib/compile/validate/defaults.ts", "../node_modules/ajv/lib/vocabularies/code.ts", "../node_modules/ajv/lib/compile/validate/keyword.ts", "../node_modules/ajv/lib/compile/validate/subschema.ts", "../node_modules/fast-deep-equal/index.js", "../node_modules/json-schema-traverse/index.js", "../node_modules/ajv/lib/compile/resolve.ts", "../node_modules/ajv/lib/compile/validate/index.ts", "../node_modules/ajv/lib/runtime/validation_error.ts", "../node_modules/ajv/lib/compile/ref_error.ts", "../node_modules/ajv/lib/compile/index.ts", "../node_modules/ajv/dist/refs/data.json", "../node_modules/fast-uri/lib/utils.js", "../node_modules/fast-uri/lib/schemes.js", "../node_modules/fast-uri/index.js", "../node_modules/ajv/lib/runtime/uri.ts", "../node_modules/ajv/lib/core.ts", "../node_modules/ajv/lib/vocabularies/core/id.ts", "../node_modules/ajv/lib/vocabularies/core/ref.ts", "../node_modules/ajv/lib/vocabularies/core/index.ts", "../node_modules/ajv/lib/vocabularies/validation/limitNumber.ts", "../node_modules/ajv/lib/vocabularies/validation/multipleOf.ts", "../node_modules/ajv/lib/runtime/ucs2length.ts", "../node_modules/ajv/lib/vocabularies/validation/limitLength.ts", "../node_modules/ajv/lib/vocabularies/validation/pattern.ts", "../node_modules/ajv/lib/vocabularies/validation/limitProperties.ts", "../node_modules/ajv/lib/vocabularies/validation/required.ts", "../node_modules/ajv/lib/vocabularies/validation/limitItems.ts", "../node_modules/ajv/lib/runtime/equal.ts", "../node_modules/ajv/lib/vocabularies/validation/uniqueItems.ts", "../node_modules/ajv/lib/vocabularies/validation/const.ts", "../node_modules/ajv/lib/vocabularies/validation/enum.ts", "../node_modules/ajv/lib/vocabularies/validation/index.ts", "../node_modules/ajv/lib/vocabularies/applicator/additionalItems.ts", "../node_modules/ajv/lib/vocabularies/applicator/items.ts", "../node_modules/ajv/lib/vocabularies/applicator/prefixItems.ts", "../node_modules/ajv/lib/vocabularies/applicator/items2020.ts", "../node_modules/ajv/lib/vocabularies/applicator/contains.ts", "../node_modules/ajv/lib/vocabularies/applicator/dependencies.ts", "../node_modules/ajv/lib/vocabularies/applicator/propertyNames.ts", "../node_modules/ajv/lib/vocabularies/applicator/additionalProperties.ts", "../node_modules/ajv/lib/vocabularies/applicator/properties.ts", "../node_modules/ajv/lib/vocabularies/applicator/patternProperties.ts", "../node_modules/ajv/lib/vocabularies/applicator/not.ts", "../node_modules/ajv/lib/vocabularies/applicator/anyOf.ts", "../node_modules/ajv/lib/vocabularies/applicator/oneOf.ts", "../node_modules/ajv/lib/vocabularies/applicator/allOf.ts", "../node_modules/ajv/lib/vocabularies/applicator/if.ts", "../node_modules/ajv/lib/vocabularies/applicator/thenElse.ts", "../node_modules/ajv/lib/vocabularies/applicator/index.ts", "../node_modules/ajv/lib/vocabularies/format/format.ts", "../node_modules/ajv/lib/vocabularies/format/index.ts", "../node_modules/ajv/lib/vocabularies/metadata.ts", "../node_modules/ajv/lib/vocabularies/draft7.ts", "../node_modules/ajv/lib/vocabularies/discriminator/types.ts", "../node_modules/ajv/lib/vocabularies/discriminator/index.ts", "../node_modules/ajv/dist/refs/json-schema-draft-07.json", "../node_modules/ajv/lib/ajv.ts", "../node_modules/ajv-formats/src/formats.ts", "../node_modules/ajv-formats/src/limit.ts", "../node_modules/ajv-formats/src/index.ts", "../node_modules/dotenv/package.json", "../node_modules/dotenv/lib/main.js", "../src/websocket-server.js", "../node_modules/ws/wrapper.mjs", "../node_modules/zod/v3/helpers/util.js", "../node_modules/zod/v3/ZodError.js", "../node_modules/zod/v3/locales/en.js", "../node_modules/zod/v3/errors.js", "../node_modules/zod/v3/helpers/parseUtil.js", "../node_modules/zod/v3/helpers/errorUtil.js", "../node_modules/zod/v3/types.js", "../node_modules/zod/v4/core/core.js", "../node_modules/zod/v4/core/util.js", "../node_modules/zod/v4/core/errors.js", "../node_modules/zod/v4/core/parse.js", "../node_modules/zod/v4/core/regexes.js", "../node_modules/zod/v4/core/checks.js", "../node_modules/zod/v4/core/doc.js", "../node_modules/zod/v4/core/versions.js", "../node_modules/zod/v4/core/schemas.js", "../node_modules/zod/v4/locales/en.js", "../node_modules/zod/v4/core/registries.js", "../node_modules/zod/v4/core/api.js", "../node_modules/zod/v4/core/to-json-schema.js", "../node_modules/zod/v4/core/json-schema-processors.js", "../node_modules/@modelcontextprotocol/sdk/src/server/zod-compat.ts", "../node_modules/zod/v4/classic/schemas.js", "../node_modules/zod/v4/classic/checks.js", "../node_modules/zod/v4/classic/iso.js", "../node_modules/zod/v4/classic/errors.js", "../node_modules/zod/v4/classic/parse.js", "../node_modules/zod/v4/classic/compat.js", "../node_modules/zod/v4/classic/from-json-schema.js", "../node_modules/zod/v4/classic/external.js", "../node_modules/@modelcontextprotocol/sdk/src/types.ts", "../node_modules/@modelcontextprotocol/sdk/src/experimental/tasks/interfaces.ts", "../node_modules/zod-to-json-schema/dist/esm/Options.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/string.js", "../node_modules/@modelcontextprotocol/sdk/src/server/zod-json-schema-compat.ts", "../node_modules/@modelcontextprotocol/sdk/src/shared/protocol.ts", "../node_modules/@modelcontextprotocol/sdk/src/validation/ajv-provider.ts", "../node_modules/@modelcontextprotocol/sdk/src/experimental/tasks/server.ts", "../node_modules/@modelcontextprotocol/sdk/src/experimental/tasks/helpers.ts", "../node_modules/@modelcontextprotocol/sdk/src/server/index.ts", "../node_modules/@modelcontextprotocol/sdk/src/server/stdio.ts", "../node_modules/@modelcontextprotocol/sdk/src/shared/stdio.ts", "../src/tokens.js", "../src/config.js", "../node_modules/env-paths/index.js", "../src/server.js"], + "sourcesContent": ["'use strict';\n\nconst BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];\nconst hasBlob = typeof Blob !== 'undefined';\n\nif (hasBlob) BINARY_TYPES.push('blob');\n\nmodule.exports = {\n BINARY_TYPES,\n CLOSE_TIMEOUT: 30000,\n EMPTY_BUFFER: Buffer.alloc(0),\n GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',\n hasBlob,\n kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),\n kListener: Symbol('kListener'),\n kStatusCode: Symbol('status-code'),\n kWebSocket: Symbol('websocket'),\n NOOP: () => {}\n};\n", "'use strict';\n\nconst { EMPTY_BUFFER } = require('./constants');\n\nconst FastBuffer = Buffer[Symbol.species];\n\n/**\n * Merges an array of buffers into a new buffer.\n *\n * @param {Buffer[]} list The array of buffers to concat\n * @param {Number} totalLength The total length of buffers in the list\n * @return {Buffer} The resulting buffer\n * @public\n */\nfunction concat(list, totalLength) {\n if (list.length === 0) return EMPTY_BUFFER;\n if (list.length === 1) return list[0];\n\n const target = Buffer.allocUnsafe(totalLength);\n let offset = 0;\n\n for (let i = 0; i < list.length; i++) {\n const buf = list[i];\n target.set(buf, offset);\n offset += buf.length;\n }\n\n if (offset < totalLength) {\n return new FastBuffer(target.buffer, target.byteOffset, offset);\n }\n\n return target;\n}\n\n/**\n * Masks a buffer using the given mask.\n *\n * @param {Buffer} source The buffer to mask\n * @param {Buffer} mask The mask to use\n * @param {Buffer} output The buffer where to store the result\n * @param {Number} offset The offset at which to start writing\n * @param {Number} length The number of bytes to mask.\n * @public\n */\nfunction _mask(source, mask, output, offset, length) {\n for (let i = 0; i < length; i++) {\n output[offset + i] = source[i] ^ mask[i & 3];\n }\n}\n\n/**\n * Unmasks a buffer using the given mask.\n *\n * @param {Buffer} buffer The buffer to unmask\n * @param {Buffer} mask The mask to use\n * @public\n */\nfunction _unmask(buffer, mask) {\n for (let i = 0; i < buffer.length; i++) {\n buffer[i] ^= mask[i & 3];\n }\n}\n\n/**\n * Converts a buffer to an `ArrayBuffer`.\n *\n * @param {Buffer} buf The buffer to convert\n * @return {ArrayBuffer} Converted buffer\n * @public\n */\nfunction toArrayBuffer(buf) {\n if (buf.length === buf.buffer.byteLength) {\n return buf.buffer;\n }\n\n return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);\n}\n\n/**\n * Converts `data` to a `Buffer`.\n *\n * @param {*} data The data to convert\n * @return {Buffer} The buffer\n * @throws {TypeError}\n * @public\n */\nfunction toBuffer(data) {\n toBuffer.readOnly = true;\n\n if (Buffer.isBuffer(data)) return data;\n\n let buf;\n\n if (data instanceof ArrayBuffer) {\n buf = new FastBuffer(data);\n } else if (ArrayBuffer.isView(data)) {\n buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);\n } else {\n buf = Buffer.from(data);\n toBuffer.readOnly = false;\n }\n\n return buf;\n}\n\nmodule.exports = {\n concat,\n mask: _mask,\n toArrayBuffer,\n toBuffer,\n unmask: _unmask\n};\n\n/* istanbul ignore else */\nif (!process.env.WS_NO_BUFFER_UTIL) {\n try {\n const bufferUtil = require('bufferutil');\n\n module.exports.mask = function (source, mask, output, offset, length) {\n if (length < 48) _mask(source, mask, output, offset, length);\n else bufferUtil.mask(source, mask, output, offset, length);\n };\n\n module.exports.unmask = function (buffer, mask) {\n if (buffer.length < 32) _unmask(buffer, mask);\n else bufferUtil.unmask(buffer, mask);\n };\n } catch (e) {\n // Continue regardless of the error.\n }\n}\n", "'use strict';\n\nconst kDone = Symbol('kDone');\nconst kRun = Symbol('kRun');\n\n/**\n * A very simple job queue with adjustable concurrency. Adapted from\n * https://github.com/STRML/async-limiter\n */\nclass Limiter {\n /**\n * Creates a new `Limiter`.\n *\n * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed\n * to run concurrently\n */\n constructor(concurrency) {\n this[kDone] = () => {\n this.pending--;\n this[kRun]();\n };\n this.concurrency = concurrency || Infinity;\n this.jobs = [];\n this.pending = 0;\n }\n\n /**\n * Adds a job to the queue.\n *\n * @param {Function} job The job to run\n * @public\n */\n add(job) {\n this.jobs.push(job);\n this[kRun]();\n }\n\n /**\n * Removes a job from the queue and runs it if possible.\n *\n * @private\n */\n [kRun]() {\n if (this.pending === this.concurrency) return;\n\n if (this.jobs.length) {\n const job = this.jobs.shift();\n\n this.pending++;\n job(this[kDone]);\n }\n }\n}\n\nmodule.exports = Limiter;\n", "'use strict';\n\nconst zlib = require('zlib');\n\nconst bufferUtil = require('./buffer-util');\nconst Limiter = require('./limiter');\nconst { kStatusCode } = require('./constants');\n\nconst FastBuffer = Buffer[Symbol.species];\nconst TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);\nconst kPerMessageDeflate = Symbol('permessage-deflate');\nconst kTotalLength = Symbol('total-length');\nconst kCallback = Symbol('callback');\nconst kBuffers = Symbol('buffers');\nconst kError = Symbol('error');\n\n//\n// We limit zlib concurrency, which prevents severe memory fragmentation\n// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913\n// and https://github.com/websockets/ws/issues/1202\n//\n// Intentionally global; it's the global thread pool that's an issue.\n//\nlet zlibLimiter;\n\n/**\n * permessage-deflate implementation.\n */\nclass PerMessageDeflate {\n /**\n * Creates a PerMessageDeflate instance.\n *\n * @param {Object} [options] Configuration options\n * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support\n * for, or request, a custom client window size\n * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/\n * acknowledge disabling of client context takeover\n * @param {Number} [options.concurrencyLimit=10] The number of concurrent\n * calls to zlib\n * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the\n * use of a custom server window size\n * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept\n * disabling of server context takeover\n * @param {Number} [options.threshold=1024] Size (in bytes) below which\n * messages should not be compressed if context takeover is disabled\n * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on\n * deflate\n * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on\n * inflate\n * @param {Boolean} [isServer=false] Create the instance in either server or\n * client mode\n * @param {Number} [maxPayload=0] The maximum allowed message length\n */\n constructor(options, isServer, maxPayload) {\n this._maxPayload = maxPayload | 0;\n this._options = options || {};\n this._threshold =\n this._options.threshold !== undefined ? this._options.threshold : 1024;\n this._isServer = !!isServer;\n this._deflate = null;\n this._inflate = null;\n\n this.params = null;\n\n if (!zlibLimiter) {\n const concurrency =\n this._options.concurrencyLimit !== undefined\n ? this._options.concurrencyLimit\n : 10;\n zlibLimiter = new Limiter(concurrency);\n }\n }\n\n /**\n * @type {String}\n */\n static get extensionName() {\n return 'permessage-deflate';\n }\n\n /**\n * Create an extension negotiation offer.\n *\n * @return {Object} Extension parameters\n * @public\n */\n offer() {\n const params = {};\n\n if (this._options.serverNoContextTakeover) {\n params.server_no_context_takeover = true;\n }\n if (this._options.clientNoContextTakeover) {\n params.client_no_context_takeover = true;\n }\n if (this._options.serverMaxWindowBits) {\n params.server_max_window_bits = this._options.serverMaxWindowBits;\n }\n if (this._options.clientMaxWindowBits) {\n params.client_max_window_bits = this._options.clientMaxWindowBits;\n } else if (this._options.clientMaxWindowBits == null) {\n params.client_max_window_bits = true;\n }\n\n return params;\n }\n\n /**\n * Accept an extension negotiation offer/response.\n *\n * @param {Array} configurations The extension negotiation offers/reponse\n * @return {Object} Accepted configuration\n * @public\n */\n accept(configurations) {\n configurations = this.normalizeParams(configurations);\n\n this.params = this._isServer\n ? this.acceptAsServer(configurations)\n : this.acceptAsClient(configurations);\n\n return this.params;\n }\n\n /**\n * Releases all resources used by the extension.\n *\n * @public\n */\n cleanup() {\n if (this._inflate) {\n this._inflate.close();\n this._inflate = null;\n }\n\n if (this._deflate) {\n const callback = this._deflate[kCallback];\n\n this._deflate.close();\n this._deflate = null;\n\n if (callback) {\n callback(\n new Error(\n 'The deflate stream was closed while data was being processed'\n )\n );\n }\n }\n }\n\n /**\n * Accept an extension negotiation offer.\n *\n * @param {Array} offers The extension negotiation offers\n * @return {Object} Accepted configuration\n * @private\n */\n acceptAsServer(offers) {\n const opts = this._options;\n const accepted = offers.find((params) => {\n if (\n (opts.serverNoContextTakeover === false &&\n params.server_no_context_takeover) ||\n (params.server_max_window_bits &&\n (opts.serverMaxWindowBits === false ||\n (typeof opts.serverMaxWindowBits === 'number' &&\n opts.serverMaxWindowBits > params.server_max_window_bits))) ||\n (typeof opts.clientMaxWindowBits === 'number' &&\n !params.client_max_window_bits)\n ) {\n return false;\n }\n\n return true;\n });\n\n if (!accepted) {\n throw new Error('None of the extension offers can be accepted');\n }\n\n if (opts.serverNoContextTakeover) {\n accepted.server_no_context_takeover = true;\n }\n if (opts.clientNoContextTakeover) {\n accepted.client_no_context_takeover = true;\n }\n if (typeof opts.serverMaxWindowBits === 'number') {\n accepted.server_max_window_bits = opts.serverMaxWindowBits;\n }\n if (typeof opts.clientMaxWindowBits === 'number') {\n accepted.client_max_window_bits = opts.clientMaxWindowBits;\n } else if (\n accepted.client_max_window_bits === true ||\n opts.clientMaxWindowBits === false\n ) {\n delete accepted.client_max_window_bits;\n }\n\n return accepted;\n }\n\n /**\n * Accept the extension negotiation response.\n *\n * @param {Array} response The extension negotiation response\n * @return {Object} Accepted configuration\n * @private\n */\n acceptAsClient(response) {\n const params = response[0];\n\n if (\n this._options.clientNoContextTakeover === false &&\n params.client_no_context_takeover\n ) {\n throw new Error('Unexpected parameter \"client_no_context_takeover\"');\n }\n\n if (!params.client_max_window_bits) {\n if (typeof this._options.clientMaxWindowBits === 'number') {\n params.client_max_window_bits = this._options.clientMaxWindowBits;\n }\n } else if (\n this._options.clientMaxWindowBits === false ||\n (typeof this._options.clientMaxWindowBits === 'number' &&\n params.client_max_window_bits > this._options.clientMaxWindowBits)\n ) {\n throw new Error(\n 'Unexpected or invalid parameter \"client_max_window_bits\"'\n );\n }\n\n return params;\n }\n\n /**\n * Normalize parameters.\n *\n * @param {Array} configurations The extension negotiation offers/reponse\n * @return {Array} The offers/response with normalized parameters\n * @private\n */\n normalizeParams(configurations) {\n configurations.forEach((params) => {\n Object.keys(params).forEach((key) => {\n let value = params[key];\n\n if (value.length > 1) {\n throw new Error(`Parameter \"${key}\" must have only a single value`);\n }\n\n value = value[0];\n\n if (key === 'client_max_window_bits') {\n if (value !== true) {\n const num = +value;\n if (!Number.isInteger(num) || num < 8 || num > 15) {\n throw new TypeError(\n `Invalid value for parameter \"${key}\": ${value}`\n );\n }\n value = num;\n } else if (!this._isServer) {\n throw new TypeError(\n `Invalid value for parameter \"${key}\": ${value}`\n );\n }\n } else if (key === 'server_max_window_bits') {\n const num = +value;\n if (!Number.isInteger(num) || num < 8 || num > 15) {\n throw new TypeError(\n `Invalid value for parameter \"${key}\": ${value}`\n );\n }\n value = num;\n } else if (\n key === 'client_no_context_takeover' ||\n key === 'server_no_context_takeover'\n ) {\n if (value !== true) {\n throw new TypeError(\n `Invalid value for parameter \"${key}\": ${value}`\n );\n }\n } else {\n throw new Error(`Unknown parameter \"${key}\"`);\n }\n\n params[key] = value;\n });\n });\n\n return configurations;\n }\n\n /**\n * Decompress data. Concurrency limited.\n *\n * @param {Buffer} data Compressed data\n * @param {Boolean} fin Specifies whether or not this is the last fragment\n * @param {Function} callback Callback\n * @public\n */\n decompress(data, fin, callback) {\n zlibLimiter.add((done) => {\n this._decompress(data, fin, (err, result) => {\n done();\n callback(err, result);\n });\n });\n }\n\n /**\n * Compress data. Concurrency limited.\n *\n * @param {(Buffer|String)} data Data to compress\n * @param {Boolean} fin Specifies whether or not this is the last fragment\n * @param {Function} callback Callback\n * @public\n */\n compress(data, fin, callback) {\n zlibLimiter.add((done) => {\n this._compress(data, fin, (err, result) => {\n done();\n callback(err, result);\n });\n });\n }\n\n /**\n * Decompress data.\n *\n * @param {Buffer} data Compressed data\n * @param {Boolean} fin Specifies whether or not this is the last fragment\n * @param {Function} callback Callback\n * @private\n */\n _decompress(data, fin, callback) {\n const endpoint = this._isServer ? 'client' : 'server';\n\n if (!this._inflate) {\n const key = `${endpoint}_max_window_bits`;\n const windowBits =\n typeof this.params[key] !== 'number'\n ? zlib.Z_DEFAULT_WINDOWBITS\n : this.params[key];\n\n this._inflate = zlib.createInflateRaw({\n ...this._options.zlibInflateOptions,\n windowBits\n });\n this._inflate[kPerMessageDeflate] = this;\n this._inflate[kTotalLength] = 0;\n this._inflate[kBuffers] = [];\n this._inflate.on('error', inflateOnError);\n this._inflate.on('data', inflateOnData);\n }\n\n this._inflate[kCallback] = callback;\n\n this._inflate.write(data);\n if (fin) this._inflate.write(TRAILER);\n\n this._inflate.flush(() => {\n const err = this._inflate[kError];\n\n if (err) {\n this._inflate.close();\n this._inflate = null;\n callback(err);\n return;\n }\n\n const data = bufferUtil.concat(\n this._inflate[kBuffers],\n this._inflate[kTotalLength]\n );\n\n if (this._inflate._readableState.endEmitted) {\n this._inflate.close();\n this._inflate = null;\n } else {\n this._inflate[kTotalLength] = 0;\n this._inflate[kBuffers] = [];\n\n if (fin && this.params[`${endpoint}_no_context_takeover`]) {\n this._inflate.reset();\n }\n }\n\n callback(null, data);\n });\n }\n\n /**\n * Compress data.\n *\n * @param {(Buffer|String)} data Data to compress\n * @param {Boolean} fin Specifies whether or not this is the last fragment\n * @param {Function} callback Callback\n * @private\n */\n _compress(data, fin, callback) {\n const endpoint = this._isServer ? 'server' : 'client';\n\n if (!this._deflate) {\n const key = `${endpoint}_max_window_bits`;\n const windowBits =\n typeof this.params[key] !== 'number'\n ? zlib.Z_DEFAULT_WINDOWBITS\n : this.params[key];\n\n this._deflate = zlib.createDeflateRaw({\n ...this._options.zlibDeflateOptions,\n windowBits\n });\n\n this._deflate[kTotalLength] = 0;\n this._deflate[kBuffers] = [];\n\n this._deflate.on('data', deflateOnData);\n }\n\n this._deflate[kCallback] = callback;\n\n this._deflate.write(data);\n this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {\n if (!this._deflate) {\n //\n // The deflate stream was closed while data was being processed.\n //\n return;\n }\n\n let data = bufferUtil.concat(\n this._deflate[kBuffers],\n this._deflate[kTotalLength]\n );\n\n if (fin) {\n data = new FastBuffer(data.buffer, data.byteOffset, data.length - 4);\n }\n\n //\n // Ensure that the callback will not be called again in\n // `PerMessageDeflate#cleanup()`.\n //\n this._deflate[kCallback] = null;\n\n this._deflate[kTotalLength] = 0;\n this._deflate[kBuffers] = [];\n\n if (fin && this.params[`${endpoint}_no_context_takeover`]) {\n this._deflate.reset();\n }\n\n callback(null, data);\n });\n }\n}\n\nmodule.exports = PerMessageDeflate;\n\n/**\n * The listener of the `zlib.DeflateRaw` stream `'data'` event.\n *\n * @param {Buffer} chunk A chunk of data\n * @private\n */\nfunction deflateOnData(chunk) {\n this[kBuffers].push(chunk);\n this[kTotalLength] += chunk.length;\n}\n\n/**\n * The listener of the `zlib.InflateRaw` stream `'data'` event.\n *\n * @param {Buffer} chunk A chunk of data\n * @private\n */\nfunction inflateOnData(chunk) {\n this[kTotalLength] += chunk.length;\n\n if (\n this[kPerMessageDeflate]._maxPayload < 1 ||\n this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload\n ) {\n this[kBuffers].push(chunk);\n return;\n }\n\n this[kError] = new RangeError('Max payload size exceeded');\n this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';\n this[kError][kStatusCode] = 1009;\n this.removeListener('data', inflateOnData);\n\n //\n // The choice to employ `zlib.reset()` over `zlib.close()` is dictated by the\n // fact that in Node.js versions prior to 13.10.0, the callback for\n // `zlib.flush()` is not called if `zlib.close()` is used. Utilizing\n // `zlib.reset()` ensures that either the callback is invoked or an error is\n // emitted.\n //\n this.reset();\n}\n\n/**\n * The listener of the `zlib.InflateRaw` stream `'error'` event.\n *\n * @param {Error} err The emitted error\n * @private\n */\nfunction inflateOnError(err) {\n //\n // There is no need to call `Zlib#close()` as the handle is automatically\n // closed when an error is emitted.\n //\n this[kPerMessageDeflate]._inflate = null;\n\n if (this[kError]) {\n this[kCallback](this[kError]);\n return;\n }\n\n err[kStatusCode] = 1007;\n this[kCallback](err);\n}\n", "'use strict';\n\nconst { isUtf8 } = require('buffer');\n\nconst { hasBlob } = require('./constants');\n\n//\n// Allowed token characters:\n//\n// '!', '#', '$', '%', '&', ''', '*', '+', '-',\n// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'\n//\n// tokenChars[32] === 0 // ' '\n// tokenChars[33] === 1 // '!'\n// tokenChars[34] === 0 // '\"'\n// ...\n//\n// prettier-ignore\nconst tokenChars = [\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31\n 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63\n 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127\n];\n\n/**\n * Checks if a status code is allowed in a close frame.\n *\n * @param {Number} code The status code\n * @return {Boolean} `true` if the status code is valid, else `false`\n * @public\n */\nfunction isValidStatusCode(code) {\n return (\n (code >= 1000 &&\n code <= 1014 &&\n code !== 1004 &&\n code !== 1005 &&\n code !== 1006) ||\n (code >= 3000 && code <= 4999)\n );\n}\n\n/**\n * Checks if a given buffer contains only correct UTF-8.\n * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by\n * Markus Kuhn.\n *\n * @param {Buffer} buf The buffer to check\n * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`\n * @public\n */\nfunction _isValidUTF8(buf) {\n const len = buf.length;\n let i = 0;\n\n while (i < len) {\n if ((buf[i] & 0x80) === 0) {\n // 0xxxxxxx\n i++;\n } else if ((buf[i] & 0xe0) === 0xc0) {\n // 110xxxxx 10xxxxxx\n if (\n i + 1 === len ||\n (buf[i + 1] & 0xc0) !== 0x80 ||\n (buf[i] & 0xfe) === 0xc0 // Overlong\n ) {\n return false;\n }\n\n i += 2;\n } else if ((buf[i] & 0xf0) === 0xe0) {\n // 1110xxxx 10xxxxxx 10xxxxxx\n if (\n i + 2 >= len ||\n (buf[i + 1] & 0xc0) !== 0x80 ||\n (buf[i + 2] & 0xc0) !== 0x80 ||\n (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong\n (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)\n ) {\n return false;\n }\n\n i += 3;\n } else if ((buf[i] & 0xf8) === 0xf0) {\n // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx\n if (\n i + 3 >= len ||\n (buf[i + 1] & 0xc0) !== 0x80 ||\n (buf[i + 2] & 0xc0) !== 0x80 ||\n (buf[i + 3] & 0xc0) !== 0x80 ||\n (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong\n (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||\n buf[i] > 0xf4 // > U+10FFFF\n ) {\n return false;\n }\n\n i += 4;\n } else {\n return false;\n }\n }\n\n return true;\n}\n\n/**\n * Determines whether a value is a `Blob`.\n *\n * @param {*} value The value to be tested\n * @return {Boolean} `true` if `value` is a `Blob`, else `false`\n * @private\n */\nfunction isBlob(value) {\n return (\n hasBlob &&\n typeof value === 'object' &&\n typeof value.arrayBuffer === 'function' &&\n typeof value.type === 'string' &&\n typeof value.stream === 'function' &&\n (value[Symbol.toStringTag] === 'Blob' ||\n value[Symbol.toStringTag] === 'File')\n );\n}\n\nmodule.exports = {\n isBlob,\n isValidStatusCode,\n isValidUTF8: _isValidUTF8,\n tokenChars\n};\n\nif (isUtf8) {\n module.exports.isValidUTF8 = function (buf) {\n return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);\n };\n} /* istanbul ignore else */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {\n try {\n const isValidUTF8 = require('utf-8-validate');\n\n module.exports.isValidUTF8 = function (buf) {\n return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);\n };\n } catch (e) {\n // Continue regardless of the error.\n }\n}\n", "'use strict';\n\nconst { Writable } = require('stream');\n\nconst PerMessageDeflate = require('./permessage-deflate');\nconst {\n BINARY_TYPES,\n EMPTY_BUFFER,\n kStatusCode,\n kWebSocket\n} = require('./constants');\nconst { concat, toArrayBuffer, unmask } = require('./buffer-util');\nconst { isValidStatusCode, isValidUTF8 } = require('./validation');\n\nconst FastBuffer = Buffer[Symbol.species];\n\nconst GET_INFO = 0;\nconst GET_PAYLOAD_LENGTH_16 = 1;\nconst GET_PAYLOAD_LENGTH_64 = 2;\nconst GET_MASK = 3;\nconst GET_DATA = 4;\nconst INFLATING = 5;\nconst DEFER_EVENT = 6;\n\n/**\n * HyBi Receiver implementation.\n *\n * @extends Writable\n */\nclass Receiver extends Writable {\n /**\n * Creates a Receiver instance.\n *\n * @param {Object} [options] Options object\n * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether\n * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted\n * multiple times in the same tick\n * @param {String} [options.binaryType=nodebuffer] The type for binary data\n * @param {Object} [options.extensions] An object containing the negotiated\n * extensions\n * @param {Boolean} [options.isServer=false] Specifies whether to operate in\n * client or server mode\n * @param {Number} [options.maxPayload=0] The maximum allowed message length\n * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or\n * not to skip UTF-8 validation for text and close messages\n */\n constructor(options = {}) {\n super();\n\n this._allowSynchronousEvents =\n options.allowSynchronousEvents !== undefined\n ? options.allowSynchronousEvents\n : true;\n this._binaryType = options.binaryType || BINARY_TYPES[0];\n this._extensions = options.extensions || {};\n this._isServer = !!options.isServer;\n this._maxPayload = options.maxPayload | 0;\n this._skipUTF8Validation = !!options.skipUTF8Validation;\n this[kWebSocket] = undefined;\n\n this._bufferedBytes = 0;\n this._buffers = [];\n\n this._compressed = false;\n this._payloadLength = 0;\n this._mask = undefined;\n this._fragmented = 0;\n this._masked = false;\n this._fin = false;\n this._opcode = 0;\n\n this._totalPayloadLength = 0;\n this._messageLength = 0;\n this._fragments = [];\n\n this._errored = false;\n this._loop = false;\n this._state = GET_INFO;\n }\n\n /**\n * Implements `Writable.prototype._write()`.\n *\n * @param {Buffer} chunk The chunk of data to write\n * @param {String} encoding The character encoding of `chunk`\n * @param {Function} cb Callback\n * @private\n */\n _write(chunk, encoding, cb) {\n if (this._opcode === 0x08 && this._state == GET_INFO) return cb();\n\n this._bufferedBytes += chunk.length;\n this._buffers.push(chunk);\n this.startLoop(cb);\n }\n\n /**\n * Consumes `n` bytes from the buffered data.\n *\n * @param {Number} n The number of bytes to consume\n * @return {Buffer} The consumed bytes\n * @private\n */\n consume(n) {\n this._bufferedBytes -= n;\n\n if (n === this._buffers[0].length) return this._buffers.shift();\n\n if (n < this._buffers[0].length) {\n const buf = this._buffers[0];\n this._buffers[0] = new FastBuffer(\n buf.buffer,\n buf.byteOffset + n,\n buf.length - n\n );\n\n return new FastBuffer(buf.buffer, buf.byteOffset, n);\n }\n\n const dst = Buffer.allocUnsafe(n);\n\n do {\n const buf = this._buffers[0];\n const offset = dst.length - n;\n\n if (n >= buf.length) {\n dst.set(this._buffers.shift(), offset);\n } else {\n dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);\n this._buffers[0] = new FastBuffer(\n buf.buffer,\n buf.byteOffset + n,\n buf.length - n\n );\n }\n\n n -= buf.length;\n } while (n > 0);\n\n return dst;\n }\n\n /**\n * Starts the parsing loop.\n *\n * @param {Function} cb Callback\n * @private\n */\n startLoop(cb) {\n this._loop = true;\n\n do {\n switch (this._state) {\n case GET_INFO:\n this.getInfo(cb);\n break;\n case GET_PAYLOAD_LENGTH_16:\n this.getPayloadLength16(cb);\n break;\n case GET_PAYLOAD_LENGTH_64:\n this.getPayloadLength64(cb);\n break;\n case GET_MASK:\n this.getMask();\n break;\n case GET_DATA:\n this.getData(cb);\n break;\n case INFLATING:\n case DEFER_EVENT:\n this._loop = false;\n return;\n }\n } while (this._loop);\n\n if (!this._errored) cb();\n }\n\n /**\n * Reads the first two bytes of a frame.\n *\n * @param {Function} cb Callback\n * @private\n */\n getInfo(cb) {\n if (this._bufferedBytes < 2) {\n this._loop = false;\n return;\n }\n\n const buf = this.consume(2);\n\n if ((buf[0] & 0x30) !== 0x00) {\n const error = this.createError(\n RangeError,\n 'RSV2 and RSV3 must be clear',\n true,\n 1002,\n 'WS_ERR_UNEXPECTED_RSV_2_3'\n );\n\n cb(error);\n return;\n }\n\n const compressed = (buf[0] & 0x40) === 0x40;\n\n if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {\n const error = this.createError(\n RangeError,\n 'RSV1 must be clear',\n true,\n 1002,\n 'WS_ERR_UNEXPECTED_RSV_1'\n );\n\n cb(error);\n return;\n }\n\n this._fin = (buf[0] & 0x80) === 0x80;\n this._opcode = buf[0] & 0x0f;\n this._payloadLength = buf[1] & 0x7f;\n\n if (this._opcode === 0x00) {\n if (compressed) {\n const error = this.createError(\n RangeError,\n 'RSV1 must be clear',\n true,\n 1002,\n 'WS_ERR_UNEXPECTED_RSV_1'\n );\n\n cb(error);\n return;\n }\n\n if (!this._fragmented) {\n const error = this.createError(\n RangeError,\n 'invalid opcode 0',\n true,\n 1002,\n 'WS_ERR_INVALID_OPCODE'\n );\n\n cb(error);\n return;\n }\n\n this._opcode = this._fragmented;\n } else if (this._opcode === 0x01 || this._opcode === 0x02) {\n if (this._fragmented) {\n const error = this.createError(\n RangeError,\n `invalid opcode ${this._opcode}`,\n true,\n 1002,\n 'WS_ERR_INVALID_OPCODE'\n );\n\n cb(error);\n return;\n }\n\n this._compressed = compressed;\n } else if (this._opcode > 0x07 && this._opcode < 0x0b) {\n if (!this._fin) {\n const error = this.createError(\n RangeError,\n 'FIN must be set',\n true,\n 1002,\n 'WS_ERR_EXPECTED_FIN'\n );\n\n cb(error);\n return;\n }\n\n if (compressed) {\n const error = this.createError(\n RangeError,\n 'RSV1 must be clear',\n true,\n 1002,\n 'WS_ERR_UNEXPECTED_RSV_1'\n );\n\n cb(error);\n return;\n }\n\n if (\n this._payloadLength > 0x7d ||\n (this._opcode === 0x08 && this._payloadLength === 1)\n ) {\n const error = this.createError(\n RangeError,\n `invalid payload length ${this._payloadLength}`,\n true,\n 1002,\n 'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'\n );\n\n cb(error);\n return;\n }\n } else {\n const error = this.createError(\n RangeError,\n `invalid opcode ${this._opcode}`,\n true,\n 1002,\n 'WS_ERR_INVALID_OPCODE'\n );\n\n cb(error);\n return;\n }\n\n if (!this._fin && !this._fragmented) this._fragmented = this._opcode;\n this._masked = (buf[1] & 0x80) === 0x80;\n\n if (this._isServer) {\n if (!this._masked) {\n const error = this.createError(\n RangeError,\n 'MASK must be set',\n true,\n 1002,\n 'WS_ERR_EXPECTED_MASK'\n );\n\n cb(error);\n return;\n }\n } else if (this._masked) {\n const error = this.createError(\n RangeError,\n 'MASK must be clear',\n true,\n 1002,\n 'WS_ERR_UNEXPECTED_MASK'\n );\n\n cb(error);\n return;\n }\n\n if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;\n else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;\n else this.haveLength(cb);\n }\n\n /**\n * Gets extended payload length (7+16).\n *\n * @param {Function} cb Callback\n * @private\n */\n getPayloadLength16(cb) {\n if (this._bufferedBytes < 2) {\n this._loop = false;\n return;\n }\n\n this._payloadLength = this.consume(2).readUInt16BE(0);\n this.haveLength(cb);\n }\n\n /**\n * Gets extended payload length (7+64).\n *\n * @param {Function} cb Callback\n * @private\n */\n getPayloadLength64(cb) {\n if (this._bufferedBytes < 8) {\n this._loop = false;\n return;\n }\n\n const buf = this.consume(8);\n const num = buf.readUInt32BE(0);\n\n //\n // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned\n // if payload length is greater than this number.\n //\n if (num > Math.pow(2, 53 - 32) - 1) {\n const error = this.createError(\n RangeError,\n 'Unsupported WebSocket frame: payload length > 2^53 - 1',\n false,\n 1009,\n 'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'\n );\n\n cb(error);\n return;\n }\n\n this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);\n this.haveLength(cb);\n }\n\n /**\n * Payload length has been read.\n *\n * @param {Function} cb Callback\n * @private\n */\n haveLength(cb) {\n if (this._payloadLength && this._opcode < 0x08) {\n this._totalPayloadLength += this._payloadLength;\n if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {\n const error = this.createError(\n RangeError,\n 'Max payload size exceeded',\n false,\n 1009,\n 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'\n );\n\n cb(error);\n return;\n }\n }\n\n if (this._masked) this._state = GET_MASK;\n else this._state = GET_DATA;\n }\n\n /**\n * Reads mask bytes.\n *\n * @private\n */\n getMask() {\n if (this._bufferedBytes < 4) {\n this._loop = false;\n return;\n }\n\n this._mask = this.consume(4);\n this._state = GET_DATA;\n }\n\n /**\n * Reads data bytes.\n *\n * @param {Function} cb Callback\n * @private\n */\n getData(cb) {\n let data = EMPTY_BUFFER;\n\n if (this._payloadLength) {\n if (this._bufferedBytes < this._payloadLength) {\n this._loop = false;\n return;\n }\n\n data = this.consume(this._payloadLength);\n\n if (\n this._masked &&\n (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0\n ) {\n unmask(data, this._mask);\n }\n }\n\n if (this._opcode > 0x07) {\n this.controlMessage(data, cb);\n return;\n }\n\n if (this._compressed) {\n this._state = INFLATING;\n this.decompress(data, cb);\n return;\n }\n\n if (data.length) {\n //\n // This message is not compressed so its length is the sum of the payload\n // length of all fragments.\n //\n this._messageLength = this._totalPayloadLength;\n this._fragments.push(data);\n }\n\n this.dataMessage(cb);\n }\n\n /**\n * Decompresses data.\n *\n * @param {Buffer} data Compressed data\n * @param {Function} cb Callback\n * @private\n */\n decompress(data, cb) {\n const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];\n\n perMessageDeflate.decompress(data, this._fin, (err, buf) => {\n if (err) return cb(err);\n\n if (buf.length) {\n this._messageLength += buf.length;\n if (this._messageLength > this._maxPayload && this._maxPayload > 0) {\n const error = this.createError(\n RangeError,\n 'Max payload size exceeded',\n false,\n 1009,\n 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'\n );\n\n cb(error);\n return;\n }\n\n this._fragments.push(buf);\n }\n\n this.dataMessage(cb);\n if (this._state === GET_INFO) this.startLoop(cb);\n });\n }\n\n /**\n * Handles a data message.\n *\n * @param {Function} cb Callback\n * @private\n */\n dataMessage(cb) {\n if (!this._fin) {\n this._state = GET_INFO;\n return;\n }\n\n const messageLength = this._messageLength;\n const fragments = this._fragments;\n\n this._totalPayloadLength = 0;\n this._messageLength = 0;\n this._fragmented = 0;\n this._fragments = [];\n\n if (this._opcode === 2) {\n let data;\n\n if (this._binaryType === 'nodebuffer') {\n data = concat(fragments, messageLength);\n } else if (this._binaryType === 'arraybuffer') {\n data = toArrayBuffer(concat(fragments, messageLength));\n } else if (this._binaryType === 'blob') {\n data = new Blob(fragments);\n } else {\n data = fragments;\n }\n\n if (this._allowSynchronousEvents) {\n this.emit('message', data, true);\n this._state = GET_INFO;\n } else {\n this._state = DEFER_EVENT;\n setImmediate(() => {\n this.emit('message', data, true);\n this._state = GET_INFO;\n this.startLoop(cb);\n });\n }\n } else {\n const buf = concat(fragments, messageLength);\n\n if (!this._skipUTF8Validation && !isValidUTF8(buf)) {\n const error = this.createError(\n Error,\n 'invalid UTF-8 sequence',\n true,\n 1007,\n 'WS_ERR_INVALID_UTF8'\n );\n\n cb(error);\n return;\n }\n\n if (this._state === INFLATING || this._allowSynchronousEvents) {\n this.emit('message', buf, false);\n this._state = GET_INFO;\n } else {\n this._state = DEFER_EVENT;\n setImmediate(() => {\n this.emit('message', buf, false);\n this._state = GET_INFO;\n this.startLoop(cb);\n });\n }\n }\n }\n\n /**\n * Handles a control message.\n *\n * @param {Buffer} data Data to handle\n * @return {(Error|RangeError|undefined)} A possible error\n * @private\n */\n controlMessage(data, cb) {\n if (this._opcode === 0x08) {\n if (data.length === 0) {\n this._loop = false;\n this.emit('conclude', 1005, EMPTY_BUFFER);\n this.end();\n } else {\n const code = data.readUInt16BE(0);\n\n if (!isValidStatusCode(code)) {\n const error = this.createError(\n RangeError,\n `invalid status code ${code}`,\n true,\n 1002,\n 'WS_ERR_INVALID_CLOSE_CODE'\n );\n\n cb(error);\n return;\n }\n\n const buf = new FastBuffer(\n data.buffer,\n data.byteOffset + 2,\n data.length - 2\n );\n\n if (!this._skipUTF8Validation && !isValidUTF8(buf)) {\n const error = this.createError(\n Error,\n 'invalid UTF-8 sequence',\n true,\n 1007,\n 'WS_ERR_INVALID_UTF8'\n );\n\n cb(error);\n return;\n }\n\n this._loop = false;\n this.emit('conclude', code, buf);\n this.end();\n }\n\n this._state = GET_INFO;\n return;\n }\n\n if (this._allowSynchronousEvents) {\n this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);\n this._state = GET_INFO;\n } else {\n this._state = DEFER_EVENT;\n setImmediate(() => {\n this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);\n this._state = GET_INFO;\n this.startLoop(cb);\n });\n }\n }\n\n /**\n * Builds an error object.\n *\n * @param {function(new:Error|RangeError)} ErrorCtor The error constructor\n * @param {String} message The error message\n * @param {Boolean} prefix Specifies whether or not to add a default prefix to\n * `message`\n * @param {Number} statusCode The status code\n * @param {String} errorCode The exposed error code\n * @return {(Error|RangeError)} The error\n * @private\n */\n createError(ErrorCtor, message, prefix, statusCode, errorCode) {\n this._loop = false;\n this._errored = true;\n\n const err = new ErrorCtor(\n prefix ? `Invalid WebSocket frame: ${message}` : message\n );\n\n Error.captureStackTrace(err, this.createError);\n err.code = errorCode;\n err[kStatusCode] = statusCode;\n return err;\n }\n}\n\nmodule.exports = Receiver;\n", "/* eslint no-unused-vars: [\"error\", { \"varsIgnorePattern\": \"^Duplex\" }] */\n\n'use strict';\n\nconst { Duplex } = require('stream');\nconst { randomFillSync } = require('crypto');\n\nconst PerMessageDeflate = require('./permessage-deflate');\nconst { EMPTY_BUFFER, kWebSocket, NOOP } = require('./constants');\nconst { isBlob, isValidStatusCode } = require('./validation');\nconst { mask: applyMask, toBuffer } = require('./buffer-util');\n\nconst kByteLength = Symbol('kByteLength');\nconst maskBuffer = Buffer.alloc(4);\nconst RANDOM_POOL_SIZE = 8 * 1024;\nlet randomPool;\nlet randomPoolPointer = RANDOM_POOL_SIZE;\n\nconst DEFAULT = 0;\nconst DEFLATING = 1;\nconst GET_BLOB_DATA = 2;\n\n/**\n * HyBi Sender implementation.\n */\nclass Sender {\n /**\n * Creates a Sender instance.\n *\n * @param {Duplex} socket The connection socket\n * @param {Object} [extensions] An object containing the negotiated extensions\n * @param {Function} [generateMask] The function used to generate the masking\n * key\n */\n constructor(socket, extensions, generateMask) {\n this._extensions = extensions || {};\n\n if (generateMask) {\n this._generateMask = generateMask;\n this._maskBuffer = Buffer.alloc(4);\n }\n\n this._socket = socket;\n\n this._firstFragment = true;\n this._compress = false;\n\n this._bufferedBytes = 0;\n this._queue = [];\n this._state = DEFAULT;\n this.onerror = NOOP;\n this[kWebSocket] = undefined;\n }\n\n /**\n * Frames a piece of data according to the HyBi WebSocket protocol.\n *\n * @param {(Buffer|String)} data The data to frame\n * @param {Object} options Options object\n * @param {Boolean} [options.fin=false] Specifies whether or not to set the\n * FIN bit\n * @param {Function} [options.generateMask] The function used to generate the\n * masking key\n * @param {Boolean} [options.mask=false] Specifies whether or not to mask\n * `data`\n * @param {Buffer} [options.maskBuffer] The buffer used to store the masking\n * key\n * @param {Number} options.opcode The opcode\n * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be\n * modified\n * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the\n * RSV1 bit\n * @return {(Buffer|String)[]} The framed data\n * @public\n */\n static frame(data, options) {\n let mask;\n let merge = false;\n let offset = 2;\n let skipMasking = false;\n\n if (options.mask) {\n mask = options.maskBuffer || maskBuffer;\n\n if (options.generateMask) {\n options.generateMask(mask);\n } else {\n if (randomPoolPointer === RANDOM_POOL_SIZE) {\n /* istanbul ignore else */\n if (randomPool === undefined) {\n //\n // This is lazily initialized because server-sent frames must not\n // be masked so it may never be used.\n //\n randomPool = Buffer.alloc(RANDOM_POOL_SIZE);\n }\n\n randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);\n randomPoolPointer = 0;\n }\n\n mask[0] = randomPool[randomPoolPointer++];\n mask[1] = randomPool[randomPoolPointer++];\n mask[2] = randomPool[randomPoolPointer++];\n mask[3] = randomPool[randomPoolPointer++];\n }\n\n skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;\n offset = 6;\n }\n\n let dataLength;\n\n if (typeof data === 'string') {\n if (\n (!options.mask || skipMasking) &&\n options[kByteLength] !== undefined\n ) {\n dataLength = options[kByteLength];\n } else {\n data = Buffer.from(data);\n dataLength = data.length;\n }\n } else {\n dataLength = data.length;\n merge = options.mask && options.readOnly && !skipMasking;\n }\n\n let payloadLength = dataLength;\n\n if (dataLength >= 65536) {\n offset += 8;\n payloadLength = 127;\n } else if (dataLength > 125) {\n offset += 2;\n payloadLength = 126;\n }\n\n const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);\n\n target[0] = options.fin ? options.opcode | 0x80 : options.opcode;\n if (options.rsv1) target[0] |= 0x40;\n\n target[1] = payloadLength;\n\n if (payloadLength === 126) {\n target.writeUInt16BE(dataLength, 2);\n } else if (payloadLength === 127) {\n target[2] = target[3] = 0;\n target.writeUIntBE(dataLength, 4, 6);\n }\n\n if (!options.mask) return [target, data];\n\n target[1] |= 0x80;\n target[offset - 4] = mask[0];\n target[offset - 3] = mask[1];\n target[offset - 2] = mask[2];\n target[offset - 1] = mask[3];\n\n if (skipMasking) return [target, data];\n\n if (merge) {\n applyMask(data, mask, target, offset, dataLength);\n return [target];\n }\n\n applyMask(data, mask, data, 0, dataLength);\n return [target, data];\n }\n\n /**\n * Sends a close message to the other peer.\n *\n * @param {Number} [code] The status code component of the body\n * @param {(String|Buffer)} [data] The message component of the body\n * @param {Boolean} [mask=false] Specifies whether or not to mask the message\n * @param {Function} [cb] Callback\n * @public\n */\n close(code, data, mask, cb) {\n let buf;\n\n if (code === undefined) {\n buf = EMPTY_BUFFER;\n } else if (typeof code !== 'number' || !isValidStatusCode(code)) {\n throw new TypeError('First argument must be a valid error code number');\n } else if (data === undefined || !data.length) {\n buf = Buffer.allocUnsafe(2);\n buf.writeUInt16BE(code, 0);\n } else {\n const length = Buffer.byteLength(data);\n\n if (length > 123) {\n throw new RangeError('The message must not be greater than 123 bytes');\n }\n\n buf = Buffer.allocUnsafe(2 + length);\n buf.writeUInt16BE(code, 0);\n\n if (typeof data === 'string') {\n buf.write(data, 2);\n } else {\n buf.set(data, 2);\n }\n }\n\n const options = {\n [kByteLength]: buf.length,\n fin: true,\n generateMask: this._generateMask,\n mask,\n maskBuffer: this._maskBuffer,\n opcode: 0x08,\n readOnly: false,\n rsv1: false\n };\n\n if (this._state !== DEFAULT) {\n this.enqueue([this.dispatch, buf, false, options, cb]);\n } else {\n this.sendFrame(Sender.frame(buf, options), cb);\n }\n }\n\n /**\n * Sends a ping message to the other peer.\n *\n * @param {*} data The message to send\n * @param {Boolean} [mask=false] Specifies whether or not to mask `data`\n * @param {Function} [cb] Callback\n * @public\n */\n ping(data, mask, cb) {\n let byteLength;\n let readOnly;\n\n if (typeof data === 'string') {\n byteLength = Buffer.byteLength(data);\n readOnly = false;\n } else if (isBlob(data)) {\n byteLength = data.size;\n readOnly = false;\n } else {\n data = toBuffer(data);\n byteLength = data.length;\n readOnly = toBuffer.readOnly;\n }\n\n if (byteLength > 125) {\n throw new RangeError('The data size must not be greater than 125 bytes');\n }\n\n const options = {\n [kByteLength]: byteLength,\n fin: true,\n generateMask: this._generateMask,\n mask,\n maskBuffer: this._maskBuffer,\n opcode: 0x09,\n readOnly,\n rsv1: false\n };\n\n if (isBlob(data)) {\n if (this._state !== DEFAULT) {\n this.enqueue([this.getBlobData, data, false, options, cb]);\n } else {\n this.getBlobData(data, false, options, cb);\n }\n } else if (this._state !== DEFAULT) {\n this.enqueue([this.dispatch, data, false, options, cb]);\n } else {\n this.sendFrame(Sender.frame(data, options), cb);\n }\n }\n\n /**\n * Sends a pong message to the other peer.\n *\n * @param {*} data The message to send\n * @param {Boolean} [mask=false] Specifies whether or not to mask `data`\n * @param {Function} [cb] Callback\n * @public\n */\n pong(data, mask, cb) {\n let byteLength;\n let readOnly;\n\n if (typeof data === 'string') {\n byteLength = Buffer.byteLength(data);\n readOnly = false;\n } else if (isBlob(data)) {\n byteLength = data.size;\n readOnly = false;\n } else {\n data = toBuffer(data);\n byteLength = data.length;\n readOnly = toBuffer.readOnly;\n }\n\n if (byteLength > 125) {\n throw new RangeError('The data size must not be greater than 125 bytes');\n }\n\n const options = {\n [kByteLength]: byteLength,\n fin: true,\n generateMask: this._generateMask,\n mask,\n maskBuffer: this._maskBuffer,\n opcode: 0x0a,\n readOnly,\n rsv1: false\n };\n\n if (isBlob(data)) {\n if (this._state !== DEFAULT) {\n this.enqueue([this.getBlobData, data, false, options, cb]);\n } else {\n this.getBlobData(data, false, options, cb);\n }\n } else if (this._state !== DEFAULT) {\n this.enqueue([this.dispatch, data, false, options, cb]);\n } else {\n this.sendFrame(Sender.frame(data, options), cb);\n }\n }\n\n /**\n * Sends a data message to the other peer.\n *\n * @param {*} data The message to send\n * @param {Object} options Options object\n * @param {Boolean} [options.binary=false] Specifies whether `data` is binary\n * or text\n * @param {Boolean} [options.compress=false] Specifies whether or not to\n * compress `data`\n * @param {Boolean} [options.fin=false] Specifies whether the fragment is the\n * last one\n * @param {Boolean} [options.mask=false] Specifies whether or not to mask\n * `data`\n * @param {Function} [cb] Callback\n * @public\n */\n send(data, options, cb) {\n const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];\n let opcode = options.binary ? 2 : 1;\n let rsv1 = options.compress;\n\n let byteLength;\n let readOnly;\n\n if (typeof data === 'string') {\n byteLength = Buffer.byteLength(data);\n readOnly = false;\n } else if (isBlob(data)) {\n byteLength = data.size;\n readOnly = false;\n } else {\n data = toBuffer(data);\n byteLength = data.length;\n readOnly = toBuffer.readOnly;\n }\n\n if (this._firstFragment) {\n this._firstFragment = false;\n if (\n rsv1 &&\n perMessageDeflate &&\n perMessageDeflate.params[\n perMessageDeflate._isServer\n ? 'server_no_context_takeover'\n : 'client_no_context_takeover'\n ]\n ) {\n rsv1 = byteLength >= perMessageDeflate._threshold;\n }\n this._compress = rsv1;\n } else {\n rsv1 = false;\n opcode = 0;\n }\n\n if (options.fin) this._firstFragment = true;\n\n const opts = {\n [kByteLength]: byteLength,\n fin: options.fin,\n generateMask: this._generateMask,\n mask: options.mask,\n maskBuffer: this._maskBuffer,\n opcode,\n readOnly,\n rsv1\n };\n\n if (isBlob(data)) {\n if (this._state !== DEFAULT) {\n this.enqueue([this.getBlobData, data, this._compress, opts, cb]);\n } else {\n this.getBlobData(data, this._compress, opts, cb);\n }\n } else if (this._state !== DEFAULT) {\n this.enqueue([this.dispatch, data, this._compress, opts, cb]);\n } else {\n this.dispatch(data, this._compress, opts, cb);\n }\n }\n\n /**\n * Gets the contents of a blob as binary data.\n *\n * @param {Blob} blob The blob\n * @param {Boolean} [compress=false] Specifies whether or not to compress\n * the data\n * @param {Object} options Options object\n * @param {Boolean} [options.fin=false] Specifies whether or not to set the\n * FIN bit\n * @param {Function} [options.generateMask] The function used to generate the\n * masking key\n * @param {Boolean} [options.mask=false] Specifies whether or not to mask\n * `data`\n * @param {Buffer} [options.maskBuffer] The buffer used to store the masking\n * key\n * @param {Number} options.opcode The opcode\n * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be\n * modified\n * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the\n * RSV1 bit\n * @param {Function} [cb] Callback\n * @private\n */\n getBlobData(blob, compress, options, cb) {\n this._bufferedBytes += options[kByteLength];\n this._state = GET_BLOB_DATA;\n\n blob\n .arrayBuffer()\n .then((arrayBuffer) => {\n if (this._socket.destroyed) {\n const err = new Error(\n 'The socket was closed while the blob was being read'\n );\n\n //\n // `callCallbacks` is called in the next tick to ensure that errors\n // that might be thrown in the callbacks behave like errors thrown\n // outside the promise chain.\n //\n process.nextTick(callCallbacks, this, err, cb);\n return;\n }\n\n this._bufferedBytes -= options[kByteLength];\n const data = toBuffer(arrayBuffer);\n\n if (!compress) {\n this._state = DEFAULT;\n this.sendFrame(Sender.frame(data, options), cb);\n this.dequeue();\n } else {\n this.dispatch(data, compress, options, cb);\n }\n })\n .catch((err) => {\n //\n // `onError` is called in the next tick for the same reason that\n // `callCallbacks` above is.\n //\n process.nextTick(onError, this, err, cb);\n });\n }\n\n /**\n * Dispatches a message.\n *\n * @param {(Buffer|String)} data The message to send\n * @param {Boolean} [compress=false] Specifies whether or not to compress\n * `data`\n * @param {Object} options Options object\n * @param {Boolean} [options.fin=false] Specifies whether or not to set the\n * FIN bit\n * @param {Function} [options.generateMask] The function used to generate the\n * masking key\n * @param {Boolean} [options.mask=false] Specifies whether or not to mask\n * `data`\n * @param {Buffer} [options.maskBuffer] The buffer used to store the masking\n * key\n * @param {Number} options.opcode The opcode\n * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be\n * modified\n * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the\n * RSV1 bit\n * @param {Function} [cb] Callback\n * @private\n */\n dispatch(data, compress, options, cb) {\n if (!compress) {\n this.sendFrame(Sender.frame(data, options), cb);\n return;\n }\n\n const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];\n\n this._bufferedBytes += options[kByteLength];\n this._state = DEFLATING;\n perMessageDeflate.compress(data, options.fin, (_, buf) => {\n if (this._socket.destroyed) {\n const err = new Error(\n 'The socket was closed while data was being compressed'\n );\n\n callCallbacks(this, err, cb);\n return;\n }\n\n this._bufferedBytes -= options[kByteLength];\n this._state = DEFAULT;\n options.readOnly = false;\n this.sendFrame(Sender.frame(buf, options), cb);\n this.dequeue();\n });\n }\n\n /**\n * Executes queued send operations.\n *\n * @private\n */\n dequeue() {\n while (this._state === DEFAULT && this._queue.length) {\n const params = this._queue.shift();\n\n this._bufferedBytes -= params[3][kByteLength];\n Reflect.apply(params[0], this, params.slice(1));\n }\n }\n\n /**\n * Enqueues a send operation.\n *\n * @param {Array} params Send operation parameters.\n * @private\n */\n enqueue(params) {\n this._bufferedBytes += params[3][kByteLength];\n this._queue.push(params);\n }\n\n /**\n * Sends a frame.\n *\n * @param {(Buffer | String)[]} list The frame to send\n * @param {Function} [cb] Callback\n * @private\n */\n sendFrame(list, cb) {\n if (list.length === 2) {\n this._socket.cork();\n this._socket.write(list[0]);\n this._socket.write(list[1], cb);\n this._socket.uncork();\n } else {\n this._socket.write(list[0], cb);\n }\n }\n}\n\nmodule.exports = Sender;\n\n/**\n * Calls queued callbacks with an error.\n *\n * @param {Sender} sender The `Sender` instance\n * @param {Error} err The error to call the callbacks with\n * @param {Function} [cb] The first callback\n * @private\n */\nfunction callCallbacks(sender, err, cb) {\n if (typeof cb === 'function') cb(err);\n\n for (let i = 0; i < sender._queue.length; i++) {\n const params = sender._queue[i];\n const callback = params[params.length - 1];\n\n if (typeof callback === 'function') callback(err);\n }\n}\n\n/**\n * Handles a `Sender` error.\n *\n * @param {Sender} sender The `Sender` instance\n * @param {Error} err The error\n * @param {Function} [cb] The first pending callback\n * @private\n */\nfunction onError(sender, err, cb) {\n callCallbacks(sender, err, cb);\n sender.onerror(err);\n}\n", "'use strict';\n\nconst { kForOnEventAttribute, kListener } = require('./constants');\n\nconst kCode = Symbol('kCode');\nconst kData = Symbol('kData');\nconst kError = Symbol('kError');\nconst kMessage = Symbol('kMessage');\nconst kReason = Symbol('kReason');\nconst kTarget = Symbol('kTarget');\nconst kType = Symbol('kType');\nconst kWasClean = Symbol('kWasClean');\n\n/**\n * Class representing an event.\n */\nclass Event {\n /**\n * Create a new `Event`.\n *\n * @param {String} type The name of the event\n * @throws {TypeError} If the `type` argument is not specified\n */\n constructor(type) {\n this[kTarget] = null;\n this[kType] = type;\n }\n\n /**\n * @type {*}\n */\n get target() {\n return this[kTarget];\n }\n\n /**\n * @type {String}\n */\n get type() {\n return this[kType];\n }\n}\n\nObject.defineProperty(Event.prototype, 'target', { enumerable: true });\nObject.defineProperty(Event.prototype, 'type', { enumerable: true });\n\n/**\n * Class representing a close event.\n *\n * @extends Event\n */\nclass CloseEvent extends Event {\n /**\n * Create a new `CloseEvent`.\n *\n * @param {String} type The name of the event\n * @param {Object} [options] A dictionary object that allows for setting\n * attributes via object members of the same name\n * @param {Number} [options.code=0] The status code explaining why the\n * connection was closed\n * @param {String} [options.reason=''] A human-readable string explaining why\n * the connection was closed\n * @param {Boolean} [options.wasClean=false] Indicates whether or not the\n * connection was cleanly closed\n */\n constructor(type, options = {}) {\n super(type);\n\n this[kCode] = options.code === undefined ? 0 : options.code;\n this[kReason] = options.reason === undefined ? '' : options.reason;\n this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;\n }\n\n /**\n * @type {Number}\n */\n get code() {\n return this[kCode];\n }\n\n /**\n * @type {String}\n */\n get reason() {\n return this[kReason];\n }\n\n /**\n * @type {Boolean}\n */\n get wasClean() {\n return this[kWasClean];\n }\n}\n\nObject.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });\nObject.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });\nObject.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });\n\n/**\n * Class representing an error event.\n *\n * @extends Event\n */\nclass ErrorEvent extends Event {\n /**\n * Create a new `ErrorEvent`.\n *\n * @param {String} type The name of the event\n * @param {Object} [options] A dictionary object that allows for setting\n * attributes via object members of the same name\n * @param {*} [options.error=null] The error that generated this event\n * @param {String} [options.message=''] The error message\n */\n constructor(type, options = {}) {\n super(type);\n\n this[kError] = options.error === undefined ? null : options.error;\n this[kMessage] = options.message === undefined ? '' : options.message;\n }\n\n /**\n * @type {*}\n */\n get error() {\n return this[kError];\n }\n\n /**\n * @type {String}\n */\n get message() {\n return this[kMessage];\n }\n}\n\nObject.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });\nObject.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });\n\n/**\n * Class representing a message event.\n *\n * @extends Event\n */\nclass MessageEvent extends Event {\n /**\n * Create a new `MessageEvent`.\n *\n * @param {String} type The name of the event\n * @param {Object} [options] A dictionary object that allows for setting\n * attributes via object members of the same name\n * @param {*} [options.data=null] The message content\n */\n constructor(type, options = {}) {\n super(type);\n\n this[kData] = options.data === undefined ? null : options.data;\n }\n\n /**\n * @type {*}\n */\n get data() {\n return this[kData];\n }\n}\n\nObject.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });\n\n/**\n * This provides methods for emulating the `EventTarget` interface. It's not\n * meant to be used directly.\n *\n * @mixin\n */\nconst EventTarget = {\n /**\n * Register an event listener.\n *\n * @param {String} type A string representing the event type to listen for\n * @param {(Function|Object)} handler The listener to add\n * @param {Object} [options] An options object specifies characteristics about\n * the event listener\n * @param {Boolean} [options.once=false] A `Boolean` indicating that the\n * listener should be invoked at most once after being added. If `true`,\n * the listener would be automatically removed when invoked.\n * @public\n */\n addEventListener(type, handler, options = {}) {\n for (const listener of this.listeners(type)) {\n if (\n !options[kForOnEventAttribute] &&\n listener[kListener] === handler &&\n !listener[kForOnEventAttribute]\n ) {\n return;\n }\n }\n\n let wrapper;\n\n if (type === 'message') {\n wrapper = function onMessage(data, isBinary) {\n const event = new MessageEvent('message', {\n data: isBinary ? data : data.toString()\n });\n\n event[kTarget] = this;\n callListener(handler, this, event);\n };\n } else if (type === 'close') {\n wrapper = function onClose(code, message) {\n const event = new CloseEvent('close', {\n code,\n reason: message.toString(),\n wasClean: this._closeFrameReceived && this._closeFrameSent\n });\n\n event[kTarget] = this;\n callListener(handler, this, event);\n };\n } else if (type === 'error') {\n wrapper = function onError(error) {\n const event = new ErrorEvent('error', {\n error,\n message: error.message\n });\n\n event[kTarget] = this;\n callListener(handler, this, event);\n };\n } else if (type === 'open') {\n wrapper = function onOpen() {\n const event = new Event('open');\n\n event[kTarget] = this;\n callListener(handler, this, event);\n };\n } else {\n return;\n }\n\n wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];\n wrapper[kListener] = handler;\n\n if (options.once) {\n this.once(type, wrapper);\n } else {\n this.on(type, wrapper);\n }\n },\n\n /**\n * Remove an event listener.\n *\n * @param {String} type A string representing the event type to remove\n * @param {(Function|Object)} handler The listener to remove\n * @public\n */\n removeEventListener(type, handler) {\n for (const listener of this.listeners(type)) {\n if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {\n this.removeListener(type, listener);\n break;\n }\n }\n }\n};\n\nmodule.exports = {\n CloseEvent,\n ErrorEvent,\n Event,\n EventTarget,\n MessageEvent\n};\n\n/**\n * Call an event listener\n *\n * @param {(Function|Object)} listener The listener to call\n * @param {*} thisArg The value to use as `this`` when calling the listener\n * @param {Event} event The event to pass to the listener\n * @private\n */\nfunction callListener(listener, thisArg, event) {\n if (typeof listener === 'object' && listener.handleEvent) {\n listener.handleEvent.call(listener, event);\n } else {\n listener.call(thisArg, event);\n }\n}\n", "'use strict';\n\nconst { tokenChars } = require('./validation');\n\n/**\n * Adds an offer to the map of extension offers or a parameter to the map of\n * parameters.\n *\n * @param {Object} dest The map of extension offers or parameters\n * @param {String} name The extension or parameter name\n * @param {(Object|Boolean|String)} elem The extension parameters or the\n * parameter value\n * @private\n */\nfunction push(dest, name, elem) {\n if (dest[name] === undefined) dest[name] = [elem];\n else dest[name].push(elem);\n}\n\n/**\n * Parses the `Sec-WebSocket-Extensions` header into an object.\n *\n * @param {String} header The field value of the header\n * @return {Object} The parsed object\n * @public\n */\nfunction parse(header) {\n const offers = Object.create(null);\n let params = Object.create(null);\n let mustUnescape = false;\n let isEscaping = false;\n let inQuotes = false;\n let extensionName;\n let paramName;\n let start = -1;\n let code = -1;\n let end = -1;\n let i = 0;\n\n for (; i < header.length; i++) {\n code = header.charCodeAt(i);\n\n if (extensionName === undefined) {\n if (end === -1 && tokenChars[code] === 1) {\n if (start === -1) start = i;\n } else if (\n i !== 0 &&\n (code === 0x20 /* ' ' */ || code === 0x09) /* '\\t' */\n ) {\n if (end === -1 && start !== -1) end = i;\n } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {\n if (start === -1) {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n\n if (end === -1) end = i;\n const name = header.slice(start, end);\n if (code === 0x2c) {\n push(offers, name, params);\n params = Object.create(null);\n } else {\n extensionName = name;\n }\n\n start = end = -1;\n } else {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n } else if (paramName === undefined) {\n if (end === -1 && tokenChars[code] === 1) {\n if (start === -1) start = i;\n } else if (code === 0x20 || code === 0x09) {\n if (end === -1 && start !== -1) end = i;\n } else if (code === 0x3b || code === 0x2c) {\n if (start === -1) {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n\n if (end === -1) end = i;\n push(params, header.slice(start, end), true);\n if (code === 0x2c) {\n push(offers, extensionName, params);\n params = Object.create(null);\n extensionName = undefined;\n }\n\n start = end = -1;\n } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {\n paramName = header.slice(start, i);\n start = end = -1;\n } else {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n } else {\n //\n // The value of a quoted-string after unescaping must conform to the\n // token ABNF, so only token characters are valid.\n // Ref: https://tools.ietf.org/html/rfc6455#section-9.1\n //\n if (isEscaping) {\n if (tokenChars[code] !== 1) {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n if (start === -1) start = i;\n else if (!mustUnescape) mustUnescape = true;\n isEscaping = false;\n } else if (inQuotes) {\n if (tokenChars[code] === 1) {\n if (start === -1) start = i;\n } else if (code === 0x22 /* '\"' */ && start !== -1) {\n inQuotes = false;\n end = i;\n } else if (code === 0x5c /* '\\' */) {\n isEscaping = true;\n } else {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {\n inQuotes = true;\n } else if (end === -1 && tokenChars[code] === 1) {\n if (start === -1) start = i;\n } else if (start !== -1 && (code === 0x20 || code === 0x09)) {\n if (end === -1) end = i;\n } else if (code === 0x3b || code === 0x2c) {\n if (start === -1) {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n\n if (end === -1) end = i;\n let value = header.slice(start, end);\n if (mustUnescape) {\n value = value.replace(/\\\\/g, '');\n mustUnescape = false;\n }\n push(params, paramName, value);\n if (code === 0x2c) {\n push(offers, extensionName, params);\n params = Object.create(null);\n extensionName = undefined;\n }\n\n paramName = undefined;\n start = end = -1;\n } else {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n }\n }\n\n if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {\n throw new SyntaxError('Unexpected end of input');\n }\n\n if (end === -1) end = i;\n const token = header.slice(start, end);\n if (extensionName === undefined) {\n push(offers, token, params);\n } else {\n if (paramName === undefined) {\n push(params, token, true);\n } else if (mustUnescape) {\n push(params, paramName, token.replace(/\\\\/g, ''));\n } else {\n push(params, paramName, token);\n }\n push(offers, extensionName, params);\n }\n\n return offers;\n}\n\n/**\n * Builds the `Sec-WebSocket-Extensions` header field value.\n *\n * @param {Object} extensions The map of extensions and parameters to format\n * @return {String} A string representing the given object\n * @public\n */\nfunction format(extensions) {\n return Object.keys(extensions)\n .map((extension) => {\n let configurations = extensions[extension];\n if (!Array.isArray(configurations)) configurations = [configurations];\n return configurations\n .map((params) => {\n return [extension]\n .concat(\n Object.keys(params).map((k) => {\n let values = params[k];\n if (!Array.isArray(values)) values = [values];\n return values\n .map((v) => (v === true ? k : `${k}=${v}`))\n .join('; ');\n })\n )\n .join('; ');\n })\n .join(', ');\n })\n .join(', ');\n}\n\nmodule.exports = { format, parse };\n", "/* eslint no-unused-vars: [\"error\", { \"varsIgnorePattern\": \"^Duplex|Readable$\", \"caughtErrors\": \"none\" }] */\n\n'use strict';\n\nconst EventEmitter = require('events');\nconst https = require('https');\nconst http = require('http');\nconst net = require('net');\nconst tls = require('tls');\nconst { randomBytes, createHash } = require('crypto');\nconst { Duplex, Readable } = require('stream');\nconst { URL } = require('url');\n\nconst PerMessageDeflate = require('./permessage-deflate');\nconst Receiver = require('./receiver');\nconst Sender = require('./sender');\nconst { isBlob } = require('./validation');\n\nconst {\n BINARY_TYPES,\n CLOSE_TIMEOUT,\n EMPTY_BUFFER,\n GUID,\n kForOnEventAttribute,\n kListener,\n kStatusCode,\n kWebSocket,\n NOOP\n} = require('./constants');\nconst {\n EventTarget: { addEventListener, removeEventListener }\n} = require('./event-target');\nconst { format, parse } = require('./extension');\nconst { toBuffer } = require('./buffer-util');\n\nconst kAborted = Symbol('kAborted');\nconst protocolVersions = [8, 13];\nconst readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];\nconst subprotocolRegex = /^[!#$%&'*+\\-.0-9A-Z^_`|a-z~]+$/;\n\n/**\n * Class representing a WebSocket.\n *\n * @extends EventEmitter\n */\nclass WebSocket extends EventEmitter {\n /**\n * Create a new `WebSocket`.\n *\n * @param {(String|URL)} address The URL to which to connect\n * @param {(String|String[])} [protocols] The subprotocols\n * @param {Object} [options] Connection options\n */\n constructor(address, protocols, options) {\n super();\n\n this._binaryType = BINARY_TYPES[0];\n this._closeCode = 1006;\n this._closeFrameReceived = false;\n this._closeFrameSent = false;\n this._closeMessage = EMPTY_BUFFER;\n this._closeTimer = null;\n this._errorEmitted = false;\n this._extensions = {};\n this._paused = false;\n this._protocol = '';\n this._readyState = WebSocket.CONNECTING;\n this._receiver = null;\n this._sender = null;\n this._socket = null;\n\n if (address !== null) {\n this._bufferedAmount = 0;\n this._isServer = false;\n this._redirects = 0;\n\n if (protocols === undefined) {\n protocols = [];\n } else if (!Array.isArray(protocols)) {\n if (typeof protocols === 'object' && protocols !== null) {\n options = protocols;\n protocols = [];\n } else {\n protocols = [protocols];\n }\n }\n\n initAsClient(this, address, protocols, options);\n } else {\n this._autoPong = options.autoPong;\n this._closeTimeout = options.closeTimeout;\n this._isServer = true;\n }\n }\n\n /**\n * For historical reasons, the custom \"nodebuffer\" type is used by the default\n * instead of \"blob\".\n *\n * @type {String}\n */\n get binaryType() {\n return this._binaryType;\n }\n\n set binaryType(type) {\n if (!BINARY_TYPES.includes(type)) return;\n\n this._binaryType = type;\n\n //\n // Allow to change `binaryType` on the fly.\n //\n if (this._receiver) this._receiver._binaryType = type;\n }\n\n /**\n * @type {Number}\n */\n get bufferedAmount() {\n if (!this._socket) return this._bufferedAmount;\n\n return this._socket._writableState.length + this._sender._bufferedBytes;\n }\n\n /**\n * @type {String}\n */\n get extensions() {\n return Object.keys(this._extensions).join();\n }\n\n /**\n * @type {Boolean}\n */\n get isPaused() {\n return this._paused;\n }\n\n /**\n * @type {Function}\n */\n /* istanbul ignore next */\n get onclose() {\n return null;\n }\n\n /**\n * @type {Function}\n */\n /* istanbul ignore next */\n get onerror() {\n return null;\n }\n\n /**\n * @type {Function}\n */\n /* istanbul ignore next */\n get onopen() {\n return null;\n }\n\n /**\n * @type {Function}\n */\n /* istanbul ignore next */\n get onmessage() {\n return null;\n }\n\n /**\n * @type {String}\n */\n get protocol() {\n return this._protocol;\n }\n\n /**\n * @type {Number}\n */\n get readyState() {\n return this._readyState;\n }\n\n /**\n * @type {String}\n */\n get url() {\n return this._url;\n }\n\n /**\n * Set up the socket and the internal resources.\n *\n * @param {Duplex} socket The network socket between the server and client\n * @param {Buffer} head The first packet of the upgraded stream\n * @param {Object} options Options object\n * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether\n * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted\n * multiple times in the same tick\n * @param {Function} [options.generateMask] The function used to generate the\n * masking key\n * @param {Number} [options.maxPayload=0] The maximum allowed message size\n * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or\n * not to skip UTF-8 validation for text and close messages\n * @private\n */\n setSocket(socket, head, options) {\n const receiver = new Receiver({\n allowSynchronousEvents: options.allowSynchronousEvents,\n binaryType: this.binaryType,\n extensions: this._extensions,\n isServer: this._isServer,\n maxPayload: options.maxPayload,\n skipUTF8Validation: options.skipUTF8Validation\n });\n\n const sender = new Sender(socket, this._extensions, options.generateMask);\n\n this._receiver = receiver;\n this._sender = sender;\n this._socket = socket;\n\n receiver[kWebSocket] = this;\n sender[kWebSocket] = this;\n socket[kWebSocket] = this;\n\n receiver.on('conclude', receiverOnConclude);\n receiver.on('drain', receiverOnDrain);\n receiver.on('error', receiverOnError);\n receiver.on('message', receiverOnMessage);\n receiver.on('ping', receiverOnPing);\n receiver.on('pong', receiverOnPong);\n\n sender.onerror = senderOnError;\n\n //\n // These methods may not be available if `socket` is just a `Duplex`.\n //\n if (socket.setTimeout) socket.setTimeout(0);\n if (socket.setNoDelay) socket.setNoDelay();\n\n if (head.length > 0) socket.unshift(head);\n\n socket.on('close', socketOnClose);\n socket.on('data', socketOnData);\n socket.on('end', socketOnEnd);\n socket.on('error', socketOnError);\n\n this._readyState = WebSocket.OPEN;\n this.emit('open');\n }\n\n /**\n * Emit the `'close'` event.\n *\n * @private\n */\n emitClose() {\n if (!this._socket) {\n this._readyState = WebSocket.CLOSED;\n this.emit('close', this._closeCode, this._closeMessage);\n return;\n }\n\n if (this._extensions[PerMessageDeflate.extensionName]) {\n this._extensions[PerMessageDeflate.extensionName].cleanup();\n }\n\n this._receiver.removeAllListeners();\n this._readyState = WebSocket.CLOSED;\n this.emit('close', this._closeCode, this._closeMessage);\n }\n\n /**\n * Start a closing handshake.\n *\n * +----------+ +-----------+ +----------+\n * - - -|ws.close()|-->|close frame|-->|ws.close()|- - -\n * | +----------+ +-----------+ +----------+ |\n * +----------+ +-----------+ |\n * CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING\n * +----------+ +-----------+ |\n * | | | +---+ |\n * +------------------------+-->|fin| - - - -\n * | +---+ | +---+\n * - - - - -|fin|<---------------------+\n * +---+\n *\n * @param {Number} [code] Status code explaining why the connection is closing\n * @param {(String|Buffer)} [data] The reason why the connection is\n * closing\n * @public\n */\n close(code, data) {\n if (this.readyState === WebSocket.CLOSED) return;\n if (this.readyState === WebSocket.CONNECTING) {\n const msg = 'WebSocket was closed before the connection was established';\n abortHandshake(this, this._req, msg);\n return;\n }\n\n if (this.readyState === WebSocket.CLOSING) {\n if (\n this._closeFrameSent &&\n (this._closeFrameReceived || this._receiver._writableState.errorEmitted)\n ) {\n this._socket.end();\n }\n\n return;\n }\n\n this._readyState = WebSocket.CLOSING;\n this._sender.close(code, data, !this._isServer, (err) => {\n //\n // This error is handled by the `'error'` listener on the socket. We only\n // want to know if the close frame has been sent here.\n //\n if (err) return;\n\n this._closeFrameSent = true;\n\n if (\n this._closeFrameReceived ||\n this._receiver._writableState.errorEmitted\n ) {\n this._socket.end();\n }\n });\n\n setCloseTimer(this);\n }\n\n /**\n * Pause the socket.\n *\n * @public\n */\n pause() {\n if (\n this.readyState === WebSocket.CONNECTING ||\n this.readyState === WebSocket.CLOSED\n ) {\n return;\n }\n\n this._paused = true;\n this._socket.pause();\n }\n\n /**\n * Send a ping.\n *\n * @param {*} [data] The data to send\n * @param {Boolean} [mask] Indicates whether or not to mask `data`\n * @param {Function} [cb] Callback which is executed when the ping is sent\n * @public\n */\n ping(data, mask, cb) {\n if (this.readyState === WebSocket.CONNECTING) {\n throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');\n }\n\n if (typeof data === 'function') {\n cb = data;\n data = mask = undefined;\n } else if (typeof mask === 'function') {\n cb = mask;\n mask = undefined;\n }\n\n if (typeof data === 'number') data = data.toString();\n\n if (this.readyState !== WebSocket.OPEN) {\n sendAfterClose(this, data, cb);\n return;\n }\n\n if (mask === undefined) mask = !this._isServer;\n this._sender.ping(data || EMPTY_BUFFER, mask, cb);\n }\n\n /**\n * Send a pong.\n *\n * @param {*} [data] The data to send\n * @param {Boolean} [mask] Indicates whether or not to mask `data`\n * @param {Function} [cb] Callback which is executed when the pong is sent\n * @public\n */\n pong(data, mask, cb) {\n if (this.readyState === WebSocket.CONNECTING) {\n throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');\n }\n\n if (typeof data === 'function') {\n cb = data;\n data = mask = undefined;\n } else if (typeof mask === 'function') {\n cb = mask;\n mask = undefined;\n }\n\n if (typeof data === 'number') data = data.toString();\n\n if (this.readyState !== WebSocket.OPEN) {\n sendAfterClose(this, data, cb);\n return;\n }\n\n if (mask === undefined) mask = !this._isServer;\n this._sender.pong(data || EMPTY_BUFFER, mask, cb);\n }\n\n /**\n * Resume the socket.\n *\n * @public\n */\n resume() {\n if (\n this.readyState === WebSocket.CONNECTING ||\n this.readyState === WebSocket.CLOSED\n ) {\n return;\n }\n\n this._paused = false;\n if (!this._receiver._writableState.needDrain) this._socket.resume();\n }\n\n /**\n * Send a data message.\n *\n * @param {*} data The message to send\n * @param {Object} [options] Options object\n * @param {Boolean} [options.binary] Specifies whether `data` is binary or\n * text\n * @param {Boolean} [options.compress] Specifies whether or not to compress\n * `data`\n * @param {Boolean} [options.fin=true] Specifies whether the fragment is the\n * last one\n * @param {Boolean} [options.mask] Specifies whether or not to mask `data`\n * @param {Function} [cb] Callback which is executed when data is written out\n * @public\n */\n send(data, options, cb) {\n if (this.readyState === WebSocket.CONNECTING) {\n throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');\n }\n\n if (typeof options === 'function') {\n cb = options;\n options = {};\n }\n\n if (typeof data === 'number') data = data.toString();\n\n if (this.readyState !== WebSocket.OPEN) {\n sendAfterClose(this, data, cb);\n return;\n }\n\n const opts = {\n binary: typeof data !== 'string',\n mask: !this._isServer,\n compress: true,\n fin: true,\n ...options\n };\n\n if (!this._extensions[PerMessageDeflate.extensionName]) {\n opts.compress = false;\n }\n\n this._sender.send(data || EMPTY_BUFFER, opts, cb);\n }\n\n /**\n * Forcibly close the connection.\n *\n * @public\n */\n terminate() {\n if (this.readyState === WebSocket.CLOSED) return;\n if (this.readyState === WebSocket.CONNECTING) {\n const msg = 'WebSocket was closed before the connection was established';\n abortHandshake(this, this._req, msg);\n return;\n }\n\n if (this._socket) {\n this._readyState = WebSocket.CLOSING;\n this._socket.destroy();\n }\n }\n}\n\n/**\n * @constant {Number} CONNECTING\n * @memberof WebSocket\n */\nObject.defineProperty(WebSocket, 'CONNECTING', {\n enumerable: true,\n value: readyStates.indexOf('CONNECTING')\n});\n\n/**\n * @constant {Number} CONNECTING\n * @memberof WebSocket.prototype\n */\nObject.defineProperty(WebSocket.prototype, 'CONNECTING', {\n enumerable: true,\n value: readyStates.indexOf('CONNECTING')\n});\n\n/**\n * @constant {Number} OPEN\n * @memberof WebSocket\n */\nObject.defineProperty(WebSocket, 'OPEN', {\n enumerable: true,\n value: readyStates.indexOf('OPEN')\n});\n\n/**\n * @constant {Number} OPEN\n * @memberof WebSocket.prototype\n */\nObject.defineProperty(WebSocket.prototype, 'OPEN', {\n enumerable: true,\n value: readyStates.indexOf('OPEN')\n});\n\n/**\n * @constant {Number} CLOSING\n * @memberof WebSocket\n */\nObject.defineProperty(WebSocket, 'CLOSING', {\n enumerable: true,\n value: readyStates.indexOf('CLOSING')\n});\n\n/**\n * @constant {Number} CLOSING\n * @memberof WebSocket.prototype\n */\nObject.defineProperty(WebSocket.prototype, 'CLOSING', {\n enumerable: true,\n value: readyStates.indexOf('CLOSING')\n});\n\n/**\n * @constant {Number} CLOSED\n * @memberof WebSocket\n */\nObject.defineProperty(WebSocket, 'CLOSED', {\n enumerable: true,\n value: readyStates.indexOf('CLOSED')\n});\n\n/**\n * @constant {Number} CLOSED\n * @memberof WebSocket.prototype\n */\nObject.defineProperty(WebSocket.prototype, 'CLOSED', {\n enumerable: true,\n value: readyStates.indexOf('CLOSED')\n});\n\n[\n 'binaryType',\n 'bufferedAmount',\n 'extensions',\n 'isPaused',\n 'protocol',\n 'readyState',\n 'url'\n].forEach((property) => {\n Object.defineProperty(WebSocket.prototype, property, { enumerable: true });\n});\n\n//\n// Add the `onopen`, `onerror`, `onclose`, and `onmessage` attributes.\n// See https://html.spec.whatwg.org/multipage/comms.html#the-websocket-interface\n//\n['open', 'error', 'close', 'message'].forEach((method) => {\n Object.defineProperty(WebSocket.prototype, `on${method}`, {\n enumerable: true,\n get() {\n for (const listener of this.listeners(method)) {\n if (listener[kForOnEventAttribute]) return listener[kListener];\n }\n\n return null;\n },\n set(handler) {\n for (const listener of this.listeners(method)) {\n if (listener[kForOnEventAttribute]) {\n this.removeListener(method, listener);\n break;\n }\n }\n\n if (typeof handler !== 'function') return;\n\n this.addEventListener(method, handler, {\n [kForOnEventAttribute]: true\n });\n }\n });\n});\n\nWebSocket.prototype.addEventListener = addEventListener;\nWebSocket.prototype.removeEventListener = removeEventListener;\n\nmodule.exports = WebSocket;\n\n/**\n * Initialize a WebSocket client.\n *\n * @param {WebSocket} websocket The client to initialize\n * @param {(String|URL)} address The URL to which to connect\n * @param {Array} protocols The subprotocols\n * @param {Object} [options] Connection options\n * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether any\n * of the `'message'`, `'ping'`, and `'pong'` events can be emitted multiple\n * times in the same tick\n * @param {Boolean} [options.autoPong=true] Specifies whether or not to\n * automatically send a pong in response to a ping\n * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to wait\n * for the closing handshake to finish after `websocket.close()` is called\n * @param {Function} [options.finishRequest] A function which can be used to\n * customize the headers of each http request before it is sent\n * @param {Boolean} [options.followRedirects=false] Whether or not to follow\n * redirects\n * @param {Function} [options.generateMask] The function used to generate the\n * masking key\n * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the\n * handshake request\n * @param {Number} [options.maxPayload=104857600] The maximum allowed message\n * size\n * @param {Number} [options.maxRedirects=10] The maximum number of redirects\n * allowed\n * @param {String} [options.origin] Value of the `Origin` or\n * `Sec-WebSocket-Origin` header\n * @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable\n * permessage-deflate\n * @param {Number} [options.protocolVersion=13] Value of the\n * `Sec-WebSocket-Version` header\n * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or\n * not to skip UTF-8 validation for text and close messages\n * @private\n */\nfunction initAsClient(websocket, address, protocols, options) {\n const opts = {\n allowSynchronousEvents: true,\n autoPong: true,\n closeTimeout: CLOSE_TIMEOUT,\n protocolVersion: protocolVersions[1],\n maxPayload: 100 * 1024 * 1024,\n skipUTF8Validation: false,\n perMessageDeflate: true,\n followRedirects: false,\n maxRedirects: 10,\n ...options,\n socketPath: undefined,\n hostname: undefined,\n protocol: undefined,\n timeout: undefined,\n method: 'GET',\n host: undefined,\n path: undefined,\n port: undefined\n };\n\n websocket._autoPong = opts.autoPong;\n websocket._closeTimeout = opts.closeTimeout;\n\n if (!protocolVersions.includes(opts.protocolVersion)) {\n throw new RangeError(\n `Unsupported protocol version: ${opts.protocolVersion} ` +\n `(supported versions: ${protocolVersions.join(', ')})`\n );\n }\n\n let parsedUrl;\n\n if (address instanceof URL) {\n parsedUrl = address;\n } else {\n try {\n parsedUrl = new URL(address);\n } catch (e) {\n throw new SyntaxError(`Invalid URL: ${address}`);\n }\n }\n\n if (parsedUrl.protocol === 'http:') {\n parsedUrl.protocol = 'ws:';\n } else if (parsedUrl.protocol === 'https:') {\n parsedUrl.protocol = 'wss:';\n }\n\n websocket._url = parsedUrl.href;\n\n const isSecure = parsedUrl.protocol === 'wss:';\n const isIpcUrl = parsedUrl.protocol === 'ws+unix:';\n let invalidUrlMessage;\n\n if (parsedUrl.protocol !== 'ws:' && !isSecure && !isIpcUrl) {\n invalidUrlMessage =\n 'The URL\\'s protocol must be one of \"ws:\", \"wss:\", ' +\n '\"http:\", \"https:\", or \"ws+unix:\"';\n } else if (isIpcUrl && !parsedUrl.pathname) {\n invalidUrlMessage = \"The URL's pathname is empty\";\n } else if (parsedUrl.hash) {\n invalidUrlMessage = 'The URL contains a fragment identifier';\n }\n\n if (invalidUrlMessage) {\n const err = new SyntaxError(invalidUrlMessage);\n\n if (websocket._redirects === 0) {\n throw err;\n } else {\n emitErrorAndClose(websocket, err);\n return;\n }\n }\n\n const defaultPort = isSecure ? 443 : 80;\n const key = randomBytes(16).toString('base64');\n const request = isSecure ? https.request : http.request;\n const protocolSet = new Set();\n let perMessageDeflate;\n\n opts.createConnection =\n opts.createConnection || (isSecure ? tlsConnect : netConnect);\n opts.defaultPort = opts.defaultPort || defaultPort;\n opts.port = parsedUrl.port || defaultPort;\n opts.host = parsedUrl.hostname.startsWith('[')\n ? parsedUrl.hostname.slice(1, -1)\n : parsedUrl.hostname;\n opts.headers = {\n ...opts.headers,\n 'Sec-WebSocket-Version': opts.protocolVersion,\n 'Sec-WebSocket-Key': key,\n Connection: 'Upgrade',\n Upgrade: 'websocket'\n };\n opts.path = parsedUrl.pathname + parsedUrl.search;\n opts.timeout = opts.handshakeTimeout;\n\n if (opts.perMessageDeflate) {\n perMessageDeflate = new PerMessageDeflate(\n opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},\n false,\n opts.maxPayload\n );\n opts.headers['Sec-WebSocket-Extensions'] = format({\n [PerMessageDeflate.extensionName]: perMessageDeflate.offer()\n });\n }\n if (protocols.length) {\n for (const protocol of protocols) {\n if (\n typeof protocol !== 'string' ||\n !subprotocolRegex.test(protocol) ||\n protocolSet.has(protocol)\n ) {\n throw new SyntaxError(\n 'An invalid or duplicated subprotocol was specified'\n );\n }\n\n protocolSet.add(protocol);\n }\n\n opts.headers['Sec-WebSocket-Protocol'] = protocols.join(',');\n }\n if (opts.origin) {\n if (opts.protocolVersion < 13) {\n opts.headers['Sec-WebSocket-Origin'] = opts.origin;\n } else {\n opts.headers.Origin = opts.origin;\n }\n }\n if (parsedUrl.username || parsedUrl.password) {\n opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;\n }\n\n if (isIpcUrl) {\n const parts = opts.path.split(':');\n\n opts.socketPath = parts[0];\n opts.path = parts[1];\n }\n\n let req;\n\n if (opts.followRedirects) {\n if (websocket._redirects === 0) {\n websocket._originalIpc = isIpcUrl;\n websocket._originalSecure = isSecure;\n websocket._originalHostOrSocketPath = isIpcUrl\n ? opts.socketPath\n : parsedUrl.host;\n\n const headers = options && options.headers;\n\n //\n // Shallow copy the user provided options so that headers can be changed\n // without mutating the original object.\n //\n options = { ...options, headers: {} };\n\n if (headers) {\n for (const [key, value] of Object.entries(headers)) {\n options.headers[key.toLowerCase()] = value;\n }\n }\n } else if (websocket.listenerCount('redirect') === 0) {\n const isSameHost = isIpcUrl\n ? websocket._originalIpc\n ? opts.socketPath === websocket._originalHostOrSocketPath\n : false\n : websocket._originalIpc\n ? false\n : parsedUrl.host === websocket._originalHostOrSocketPath;\n\n if (!isSameHost || (websocket._originalSecure && !isSecure)) {\n //\n // Match curl 7.77.0 behavior and drop the following headers. These\n // headers are also dropped when following a redirect to a subdomain.\n //\n delete opts.headers.authorization;\n delete opts.headers.cookie;\n\n if (!isSameHost) delete opts.headers.host;\n\n opts.auth = undefined;\n }\n }\n\n //\n // Match curl 7.77.0 behavior and make the first `Authorization` header win.\n // If the `Authorization` header is set, then there is nothing to do as it\n // will take precedence.\n //\n if (opts.auth && !options.headers.authorization) {\n options.headers.authorization =\n 'Basic ' + Buffer.from(opts.auth).toString('base64');\n }\n\n req = websocket._req = request(opts);\n\n if (websocket._redirects) {\n //\n // Unlike what is done for the `'upgrade'` event, no early exit is\n // triggered here if the user calls `websocket.close()` or\n // `websocket.terminate()` from a listener of the `'redirect'` event. This\n // is because the user can also call `request.destroy()` with an error\n // before calling `websocket.close()` or `websocket.terminate()` and this\n // would result in an error being emitted on the `request` object with no\n // `'error'` event listeners attached.\n //\n websocket.emit('redirect', websocket.url, req);\n }\n } else {\n req = websocket._req = request(opts);\n }\n\n if (opts.timeout) {\n req.on('timeout', () => {\n abortHandshake(websocket, req, 'Opening handshake has timed out');\n });\n }\n\n req.on('error', (err) => {\n if (req === null || req[kAborted]) return;\n\n req = websocket._req = null;\n emitErrorAndClose(websocket, err);\n });\n\n req.on('response', (res) => {\n const location = res.headers.location;\n const statusCode = res.statusCode;\n\n if (\n location &&\n opts.followRedirects &&\n statusCode >= 300 &&\n statusCode < 400\n ) {\n if (++websocket._redirects > opts.maxRedirects) {\n abortHandshake(websocket, req, 'Maximum redirects exceeded');\n return;\n }\n\n req.abort();\n\n let addr;\n\n try {\n addr = new URL(location, address);\n } catch (e) {\n const err = new SyntaxError(`Invalid URL: ${location}`);\n emitErrorAndClose(websocket, err);\n return;\n }\n\n initAsClient(websocket, addr, protocols, options);\n } else if (!websocket.emit('unexpected-response', req, res)) {\n abortHandshake(\n websocket,\n req,\n `Unexpected server response: ${res.statusCode}`\n );\n }\n });\n\n req.on('upgrade', (res, socket, head) => {\n websocket.emit('upgrade', res);\n\n //\n // The user may have closed the connection from a listener of the\n // `'upgrade'` event.\n //\n if (websocket.readyState !== WebSocket.CONNECTING) return;\n\n req = websocket._req = null;\n\n const upgrade = res.headers.upgrade;\n\n if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {\n abortHandshake(websocket, socket, 'Invalid Upgrade header');\n return;\n }\n\n const digest = createHash('sha1')\n .update(key + GUID)\n .digest('base64');\n\n if (res.headers['sec-websocket-accept'] !== digest) {\n abortHandshake(websocket, socket, 'Invalid Sec-WebSocket-Accept header');\n return;\n }\n\n const serverProt = res.headers['sec-websocket-protocol'];\n let protError;\n\n if (serverProt !== undefined) {\n if (!protocolSet.size) {\n protError = 'Server sent a subprotocol but none was requested';\n } else if (!protocolSet.has(serverProt)) {\n protError = 'Server sent an invalid subprotocol';\n }\n } else if (protocolSet.size) {\n protError = 'Server sent no subprotocol';\n }\n\n if (protError) {\n abortHandshake(websocket, socket, protError);\n return;\n }\n\n if (serverProt) websocket._protocol = serverProt;\n\n const secWebSocketExtensions = res.headers['sec-websocket-extensions'];\n\n if (secWebSocketExtensions !== undefined) {\n if (!perMessageDeflate) {\n const message =\n 'Server sent a Sec-WebSocket-Extensions header but no extension ' +\n 'was requested';\n abortHandshake(websocket, socket, message);\n return;\n }\n\n let extensions;\n\n try {\n extensions = parse(secWebSocketExtensions);\n } catch (err) {\n const message = 'Invalid Sec-WebSocket-Extensions header';\n abortHandshake(websocket, socket, message);\n return;\n }\n\n const extensionNames = Object.keys(extensions);\n\n if (\n extensionNames.length !== 1 ||\n extensionNames[0] !== PerMessageDeflate.extensionName\n ) {\n const message = 'Server indicated an extension that was not requested';\n abortHandshake(websocket, socket, message);\n return;\n }\n\n try {\n perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);\n } catch (err) {\n const message = 'Invalid Sec-WebSocket-Extensions header';\n abortHandshake(websocket, socket, message);\n return;\n }\n\n websocket._extensions[PerMessageDeflate.extensionName] =\n perMessageDeflate;\n }\n\n websocket.setSocket(socket, head, {\n allowSynchronousEvents: opts.allowSynchronousEvents,\n generateMask: opts.generateMask,\n maxPayload: opts.maxPayload,\n skipUTF8Validation: opts.skipUTF8Validation\n });\n });\n\n if (opts.finishRequest) {\n opts.finishRequest(req, websocket);\n } else {\n req.end();\n }\n}\n\n/**\n * Emit the `'error'` and `'close'` events.\n *\n * @param {WebSocket} websocket The WebSocket instance\n * @param {Error} The error to emit\n * @private\n */\nfunction emitErrorAndClose(websocket, err) {\n websocket._readyState = WebSocket.CLOSING;\n //\n // The following assignment is practically useless and is done only for\n // consistency.\n //\n websocket._errorEmitted = true;\n websocket.emit('error', err);\n websocket.emitClose();\n}\n\n/**\n * Create a `net.Socket` and initiate a connection.\n *\n * @param {Object} options Connection options\n * @return {net.Socket} The newly created socket used to start the connection\n * @private\n */\nfunction netConnect(options) {\n options.path = options.socketPath;\n return net.connect(options);\n}\n\n/**\n * Create a `tls.TLSSocket` and initiate a connection.\n *\n * @param {Object} options Connection options\n * @return {tls.TLSSocket} The newly created socket used to start the connection\n * @private\n */\nfunction tlsConnect(options) {\n options.path = undefined;\n\n if (!options.servername && options.servername !== '') {\n options.servername = net.isIP(options.host) ? '' : options.host;\n }\n\n return tls.connect(options);\n}\n\n/**\n * Abort the handshake and emit an error.\n *\n * @param {WebSocket} websocket The WebSocket instance\n * @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to\n * abort or the socket to destroy\n * @param {String} message The error message\n * @private\n */\nfunction abortHandshake(websocket, stream, message) {\n websocket._readyState = WebSocket.CLOSING;\n\n const err = new Error(message);\n Error.captureStackTrace(err, abortHandshake);\n\n if (stream.setHeader) {\n stream[kAborted] = true;\n stream.abort();\n\n if (stream.socket && !stream.socket.destroyed) {\n //\n // On Node.js >= 14.3.0 `request.abort()` does not destroy the socket if\n // called after the request completed. See\n // https://github.com/websockets/ws/issues/1869.\n //\n stream.socket.destroy();\n }\n\n process.nextTick(emitErrorAndClose, websocket, err);\n } else {\n stream.destroy(err);\n stream.once('error', websocket.emit.bind(websocket, 'error'));\n stream.once('close', websocket.emitClose.bind(websocket));\n }\n}\n\n/**\n * Handle cases where the `ping()`, `pong()`, or `send()` methods are called\n * when the `readyState` attribute is `CLOSING` or `CLOSED`.\n *\n * @param {WebSocket} websocket The WebSocket instance\n * @param {*} [data] The data to send\n * @param {Function} [cb] Callback\n * @private\n */\nfunction sendAfterClose(websocket, data, cb) {\n if (data) {\n const length = isBlob(data) ? data.size : toBuffer(data).length;\n\n //\n // The `_bufferedAmount` property is used only when the peer is a client and\n // the opening handshake fails. Under these circumstances, in fact, the\n // `setSocket()` method is not called, so the `_socket` and `_sender`\n // properties are set to `null`.\n //\n if (websocket._socket) websocket._sender._bufferedBytes += length;\n else websocket._bufferedAmount += length;\n }\n\n if (cb) {\n const err = new Error(\n `WebSocket is not open: readyState ${websocket.readyState} ` +\n `(${readyStates[websocket.readyState]})`\n );\n process.nextTick(cb, err);\n }\n}\n\n/**\n * The listener of the `Receiver` `'conclude'` event.\n *\n * @param {Number} code The status code\n * @param {Buffer} reason The reason for closing\n * @private\n */\nfunction receiverOnConclude(code, reason) {\n const websocket = this[kWebSocket];\n\n websocket._closeFrameReceived = true;\n websocket._closeMessage = reason;\n websocket._closeCode = code;\n\n if (websocket._socket[kWebSocket] === undefined) return;\n\n websocket._socket.removeListener('data', socketOnData);\n process.nextTick(resume, websocket._socket);\n\n if (code === 1005) websocket.close();\n else websocket.close(code, reason);\n}\n\n/**\n * The listener of the `Receiver` `'drain'` event.\n *\n * @private\n */\nfunction receiverOnDrain() {\n const websocket = this[kWebSocket];\n\n if (!websocket.isPaused) websocket._socket.resume();\n}\n\n/**\n * The listener of the `Receiver` `'error'` event.\n *\n * @param {(RangeError|Error)} err The emitted error\n * @private\n */\nfunction receiverOnError(err) {\n const websocket = this[kWebSocket];\n\n if (websocket._socket[kWebSocket] !== undefined) {\n websocket._socket.removeListener('data', socketOnData);\n\n //\n // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See\n // https://github.com/websockets/ws/issues/1940.\n //\n process.nextTick(resume, websocket._socket);\n\n websocket.close(err[kStatusCode]);\n }\n\n if (!websocket._errorEmitted) {\n websocket._errorEmitted = true;\n websocket.emit('error', err);\n }\n}\n\n/**\n * The listener of the `Receiver` `'finish'` event.\n *\n * @private\n */\nfunction receiverOnFinish() {\n this[kWebSocket].emitClose();\n}\n\n/**\n * The listener of the `Receiver` `'message'` event.\n *\n * @param {Buffer|ArrayBuffer|Buffer[])} data The message\n * @param {Boolean} isBinary Specifies whether the message is binary or not\n * @private\n */\nfunction receiverOnMessage(data, isBinary) {\n this[kWebSocket].emit('message', data, isBinary);\n}\n\n/**\n * The listener of the `Receiver` `'ping'` event.\n *\n * @param {Buffer} data The data included in the ping frame\n * @private\n */\nfunction receiverOnPing(data) {\n const websocket = this[kWebSocket];\n\n if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);\n websocket.emit('ping', data);\n}\n\n/**\n * The listener of the `Receiver` `'pong'` event.\n *\n * @param {Buffer} data The data included in the pong frame\n * @private\n */\nfunction receiverOnPong(data) {\n this[kWebSocket].emit('pong', data);\n}\n\n/**\n * Resume a readable stream\n *\n * @param {Readable} stream The readable stream\n * @private\n */\nfunction resume(stream) {\n stream.resume();\n}\n\n/**\n * The `Sender` error event handler.\n *\n * @param {Error} The error\n * @private\n */\nfunction senderOnError(err) {\n const websocket = this[kWebSocket];\n\n if (websocket.readyState === WebSocket.CLOSED) return;\n if (websocket.readyState === WebSocket.OPEN) {\n websocket._readyState = WebSocket.CLOSING;\n setCloseTimer(websocket);\n }\n\n //\n // `socket.end()` is used instead of `socket.destroy()` to allow the other\n // peer to finish sending queued data. There is no need to set a timer here\n // because `CLOSING` means that it is already set or not needed.\n //\n this._socket.end();\n\n if (!websocket._errorEmitted) {\n websocket._errorEmitted = true;\n websocket.emit('error', err);\n }\n}\n\n/**\n * Set a timer to destroy the underlying raw socket of a WebSocket.\n *\n * @param {WebSocket} websocket The WebSocket instance\n * @private\n */\nfunction setCloseTimer(websocket) {\n websocket._closeTimer = setTimeout(\n websocket._socket.destroy.bind(websocket._socket),\n websocket._closeTimeout\n );\n}\n\n/**\n * The listener of the socket `'close'` event.\n *\n * @private\n */\nfunction socketOnClose() {\n const websocket = this[kWebSocket];\n\n this.removeListener('close', socketOnClose);\n this.removeListener('data', socketOnData);\n this.removeListener('end', socketOnEnd);\n\n websocket._readyState = WebSocket.CLOSING;\n\n //\n // The close frame might not have been received or the `'end'` event emitted,\n // for example, if the socket was destroyed due to an error. Ensure that the\n // `receiver` stream is closed after writing any remaining buffered data to\n // it. If the readable side of the socket is in flowing mode then there is no\n // buffered data as everything has been already written. If instead, the\n // socket is paused, any possible buffered data will be read as a single\n // chunk.\n //\n if (\n !this._readableState.endEmitted &&\n !websocket._closeFrameReceived &&\n !websocket._receiver._writableState.errorEmitted &&\n this._readableState.length !== 0\n ) {\n const chunk = this.read(this._readableState.length);\n\n websocket._receiver.write(chunk);\n }\n\n websocket._receiver.end();\n\n this[kWebSocket] = undefined;\n\n clearTimeout(websocket._closeTimer);\n\n if (\n websocket._receiver._writableState.finished ||\n websocket._receiver._writableState.errorEmitted\n ) {\n websocket.emitClose();\n } else {\n websocket._receiver.on('error', receiverOnFinish);\n websocket._receiver.on('finish', receiverOnFinish);\n }\n}\n\n/**\n * The listener of the socket `'data'` event.\n *\n * @param {Buffer} chunk A chunk of data\n * @private\n */\nfunction socketOnData(chunk) {\n if (!this[kWebSocket]._receiver.write(chunk)) {\n this.pause();\n }\n}\n\n/**\n * The listener of the socket `'end'` event.\n *\n * @private\n */\nfunction socketOnEnd() {\n const websocket = this[kWebSocket];\n\n websocket._readyState = WebSocket.CLOSING;\n websocket._receiver.end();\n this.end();\n}\n\n/**\n * The listener of the socket `'error'` event.\n *\n * @private\n */\nfunction socketOnError() {\n const websocket = this[kWebSocket];\n\n this.removeListener('error', socketOnError);\n this.on('error', NOOP);\n\n if (websocket) {\n websocket._readyState = WebSocket.CLOSING;\n this.destroy();\n }\n}\n", "/* eslint no-unused-vars: [\"error\", { \"varsIgnorePattern\": \"^WebSocket$\" }] */\n'use strict';\n\nconst WebSocket = require('./websocket');\nconst { Duplex } = require('stream');\n\n/**\n * Emits the `'close'` event on a stream.\n *\n * @param {Duplex} stream The stream.\n * @private\n */\nfunction emitClose(stream) {\n stream.emit('close');\n}\n\n/**\n * The listener of the `'end'` event.\n *\n * @private\n */\nfunction duplexOnEnd() {\n if (!this.destroyed && this._writableState.finished) {\n this.destroy();\n }\n}\n\n/**\n * The listener of the `'error'` event.\n *\n * @param {Error} err The error\n * @private\n */\nfunction duplexOnError(err) {\n this.removeListener('error', duplexOnError);\n this.destroy();\n if (this.listenerCount('error') === 0) {\n // Do not suppress the throwing behavior.\n this.emit('error', err);\n }\n}\n\n/**\n * Wraps a `WebSocket` in a duplex stream.\n *\n * @param {WebSocket} ws The `WebSocket` to wrap\n * @param {Object} [options] The options for the `Duplex` constructor\n * @return {Duplex} The duplex stream\n * @public\n */\nfunction createWebSocketStream(ws, options) {\n let terminateOnDestroy = true;\n\n const duplex = new Duplex({\n ...options,\n autoDestroy: false,\n emitClose: false,\n objectMode: false,\n writableObjectMode: false\n });\n\n ws.on('message', function message(msg, isBinary) {\n const data =\n !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;\n\n if (!duplex.push(data)) ws.pause();\n });\n\n ws.once('error', function error(err) {\n if (duplex.destroyed) return;\n\n // Prevent `ws.terminate()` from being called by `duplex._destroy()`.\n //\n // - If the `'error'` event is emitted before the `'open'` event, then\n // `ws.terminate()` is a noop as no socket is assigned.\n // - Otherwise, the error is re-emitted by the listener of the `'error'`\n // event of the `Receiver` object. The listener already closes the\n // connection by calling `ws.close()`. This allows a close frame to be\n // sent to the other peer. If `ws.terminate()` is called right after this,\n // then the close frame might not be sent.\n terminateOnDestroy = false;\n duplex.destroy(err);\n });\n\n ws.once('close', function close() {\n if (duplex.destroyed) return;\n\n duplex.push(null);\n });\n\n duplex._destroy = function (err, callback) {\n if (ws.readyState === ws.CLOSED) {\n callback(err);\n process.nextTick(emitClose, duplex);\n return;\n }\n\n let called = false;\n\n ws.once('error', function error(err) {\n called = true;\n callback(err);\n });\n\n ws.once('close', function close() {\n if (!called) callback(err);\n process.nextTick(emitClose, duplex);\n });\n\n if (terminateOnDestroy) ws.terminate();\n };\n\n duplex._final = function (callback) {\n if (ws.readyState === ws.CONNECTING) {\n ws.once('open', function open() {\n duplex._final(callback);\n });\n return;\n }\n\n // If the value of the `_socket` property is `null` it means that `ws` is a\n // client websocket and the handshake failed. In fact, when this happens, a\n // socket is never assigned to the websocket. Wait for the `'error'` event\n // that will be emitted by the websocket.\n if (ws._socket === null) return;\n\n if (ws._socket._writableState.finished) {\n callback();\n if (duplex._readableState.endEmitted) duplex.destroy();\n } else {\n ws._socket.once('finish', function finish() {\n // `duplex` is not destroyed here because the `'end'` event will be\n // emitted on `duplex` after this `'finish'` event. The EOF signaling\n // `null` chunk is, in fact, pushed when the websocket emits `'close'`.\n callback();\n });\n ws.close();\n }\n };\n\n duplex._read = function () {\n if (ws.isPaused) ws.resume();\n };\n\n duplex._write = function (chunk, encoding, callback) {\n if (ws.readyState === ws.CONNECTING) {\n ws.once('open', function open() {\n duplex._write(chunk, encoding, callback);\n });\n return;\n }\n\n ws.send(chunk, callback);\n };\n\n duplex.on('end', duplexOnEnd);\n duplex.on('error', duplexOnError);\n return duplex;\n}\n\nmodule.exports = createWebSocketStream;\n", "'use strict';\n\nconst { tokenChars } = require('./validation');\n\n/**\n * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.\n *\n * @param {String} header The field value of the header\n * @return {Set} The subprotocol names\n * @public\n */\nfunction parse(header) {\n const protocols = new Set();\n let start = -1;\n let end = -1;\n let i = 0;\n\n for (i; i < header.length; i++) {\n const code = header.charCodeAt(i);\n\n if (end === -1 && tokenChars[code] === 1) {\n if (start === -1) start = i;\n } else if (\n i !== 0 &&\n (code === 0x20 /* ' ' */ || code === 0x09) /* '\\t' */\n ) {\n if (end === -1 && start !== -1) end = i;\n } else if (code === 0x2c /* ',' */) {\n if (start === -1) {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n\n if (end === -1) end = i;\n\n const protocol = header.slice(start, end);\n\n if (protocols.has(protocol)) {\n throw new SyntaxError(`The \"${protocol}\" subprotocol is duplicated`);\n }\n\n protocols.add(protocol);\n start = end = -1;\n } else {\n throw new SyntaxError(`Unexpected character at index ${i}`);\n }\n }\n\n if (start === -1 || end !== -1) {\n throw new SyntaxError('Unexpected end of input');\n }\n\n const protocol = header.slice(start, i);\n\n if (protocols.has(protocol)) {\n throw new SyntaxError(`The \"${protocol}\" subprotocol is duplicated`);\n }\n\n protocols.add(protocol);\n return protocols;\n}\n\nmodule.exports = { parse };\n", "/* eslint no-unused-vars: [\"error\", { \"varsIgnorePattern\": \"^Duplex$\", \"caughtErrors\": \"none\" }] */\n\n'use strict';\n\nconst EventEmitter = require('events');\nconst http = require('http');\nconst { Duplex } = require('stream');\nconst { createHash } = require('crypto');\n\nconst extension = require('./extension');\nconst PerMessageDeflate = require('./permessage-deflate');\nconst subprotocol = require('./subprotocol');\nconst WebSocket = require('./websocket');\nconst { CLOSE_TIMEOUT, GUID, kWebSocket } = require('./constants');\n\nconst keyRegex = /^[+/0-9A-Za-z]{22}==$/;\n\nconst RUNNING = 0;\nconst CLOSING = 1;\nconst CLOSED = 2;\n\n/**\n * Class representing a WebSocket server.\n *\n * @extends EventEmitter\n */\nclass WebSocketServer extends EventEmitter {\n /**\n * Create a `WebSocketServer` instance.\n *\n * @param {Object} options Configuration options\n * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether\n * any of the `'message'`, `'ping'`, and `'pong'` events can be emitted\n * multiple times in the same tick\n * @param {Boolean} [options.autoPong=true] Specifies whether or not to\n * automatically send a pong in response to a ping\n * @param {Number} [options.backlog=511] The maximum length of the queue of\n * pending connections\n * @param {Boolean} [options.clientTracking=true] Specifies whether or not to\n * track clients\n * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to\n * wait for the closing handshake to finish after `websocket.close()` is\n * called\n * @param {Function} [options.handleProtocols] A hook to handle protocols\n * @param {String} [options.host] The hostname where to bind the server\n * @param {Number} [options.maxPayload=104857600] The maximum allowed message\n * size\n * @param {Boolean} [options.noServer=false] Enable no server mode\n * @param {String} [options.path] Accept only connections matching this path\n * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable\n * permessage-deflate\n * @param {Number} [options.port] The port where to bind the server\n * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S\n * server to use\n * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or\n * not to skip UTF-8 validation for text and close messages\n * @param {Function} [options.verifyClient] A hook to reject connections\n * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`\n * class to use. It must be the `WebSocket` class or class that extends it\n * @param {Function} [callback] A listener for the `listening` event\n */\n constructor(options, callback) {\n super();\n\n options = {\n allowSynchronousEvents: true,\n autoPong: true,\n maxPayload: 100 * 1024 * 1024,\n skipUTF8Validation: false,\n perMessageDeflate: false,\n handleProtocols: null,\n clientTracking: true,\n closeTimeout: CLOSE_TIMEOUT,\n verifyClient: null,\n noServer: false,\n backlog: null, // use default (511 as implemented in net.js)\n server: null,\n host: null,\n path: null,\n port: null,\n WebSocket,\n ...options\n };\n\n if (\n (options.port == null && !options.server && !options.noServer) ||\n (options.port != null && (options.server || options.noServer)) ||\n (options.server && options.noServer)\n ) {\n throw new TypeError(\n 'One and only one of the \"port\", \"server\", or \"noServer\" options ' +\n 'must be specified'\n );\n }\n\n if (options.port != null) {\n this._server = http.createServer((req, res) => {\n const body = http.STATUS_CODES[426];\n\n res.writeHead(426, {\n 'Content-Length': body.length,\n 'Content-Type': 'text/plain'\n });\n res.end(body);\n });\n this._server.listen(\n options.port,\n options.host,\n options.backlog,\n callback\n );\n } else if (options.server) {\n this._server = options.server;\n }\n\n if (this._server) {\n const emitConnection = this.emit.bind(this, 'connection');\n\n this._removeListeners = addListeners(this._server, {\n listening: this.emit.bind(this, 'listening'),\n error: this.emit.bind(this, 'error'),\n upgrade: (req, socket, head) => {\n this.handleUpgrade(req, socket, head, emitConnection);\n }\n });\n }\n\n if (options.perMessageDeflate === true) options.perMessageDeflate = {};\n if (options.clientTracking) {\n this.clients = new Set();\n this._shouldEmitClose = false;\n }\n\n this.options = options;\n this._state = RUNNING;\n }\n\n /**\n * Returns the bound address, the address family name, and port of the server\n * as reported by the operating system if listening on an IP socket.\n * If the server is listening on a pipe or UNIX domain socket, the name is\n * returned as a string.\n *\n * @return {(Object|String|null)} The address of the server\n * @public\n */\n address() {\n if (this.options.noServer) {\n throw new Error('The server is operating in \"noServer\" mode');\n }\n\n if (!this._server) return null;\n return this._server.address();\n }\n\n /**\n * Stop the server from accepting new connections and emit the `'close'` event\n * when all existing connections are closed.\n *\n * @param {Function} [cb] A one-time listener for the `'close'` event\n * @public\n */\n close(cb) {\n if (this._state === CLOSED) {\n if (cb) {\n this.once('close', () => {\n cb(new Error('The server is not running'));\n });\n }\n\n process.nextTick(emitClose, this);\n return;\n }\n\n if (cb) this.once('close', cb);\n\n if (this._state === CLOSING) return;\n this._state = CLOSING;\n\n if (this.options.noServer || this.options.server) {\n if (this._server) {\n this._removeListeners();\n this._removeListeners = this._server = null;\n }\n\n if (this.clients) {\n if (!this.clients.size) {\n process.nextTick(emitClose, this);\n } else {\n this._shouldEmitClose = true;\n }\n } else {\n process.nextTick(emitClose, this);\n }\n } else {\n const server = this._server;\n\n this._removeListeners();\n this._removeListeners = this._server = null;\n\n //\n // The HTTP/S server was created internally. Close it, and rely on its\n // `'close'` event.\n //\n server.close(() => {\n emitClose(this);\n });\n }\n }\n\n /**\n * See if a given request should be handled by this server instance.\n *\n * @param {http.IncomingMessage} req Request object to inspect\n * @return {Boolean} `true` if the request is valid, else `false`\n * @public\n */\n shouldHandle(req) {\n if (this.options.path) {\n const index = req.url.indexOf('?');\n const pathname = index !== -1 ? req.url.slice(0, index) : req.url;\n\n if (pathname !== this.options.path) return false;\n }\n\n return true;\n }\n\n /**\n * Handle a HTTP Upgrade request.\n *\n * @param {http.IncomingMessage} req The request object\n * @param {Duplex} socket The network socket between the server and client\n * @param {Buffer} head The first packet of the upgraded stream\n * @param {Function} cb Callback\n * @public\n */\n handleUpgrade(req, socket, head, cb) {\n socket.on('error', socketOnError);\n\n const key = req.headers['sec-websocket-key'];\n const upgrade = req.headers.upgrade;\n const version = +req.headers['sec-websocket-version'];\n\n if (req.method !== 'GET') {\n const message = 'Invalid HTTP method';\n abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);\n return;\n }\n\n if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {\n const message = 'Invalid Upgrade header';\n abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);\n return;\n }\n\n if (key === undefined || !keyRegex.test(key)) {\n const message = 'Missing or invalid Sec-WebSocket-Key header';\n abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);\n return;\n }\n\n if (version !== 13 && version !== 8) {\n const message = 'Missing or invalid Sec-WebSocket-Version header';\n abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {\n 'Sec-WebSocket-Version': '13, 8'\n });\n return;\n }\n\n if (!this.shouldHandle(req)) {\n abortHandshake(socket, 400);\n return;\n }\n\n const secWebSocketProtocol = req.headers['sec-websocket-protocol'];\n let protocols = new Set();\n\n if (secWebSocketProtocol !== undefined) {\n try {\n protocols = subprotocol.parse(secWebSocketProtocol);\n } catch (err) {\n const message = 'Invalid Sec-WebSocket-Protocol header';\n abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);\n return;\n }\n }\n\n const secWebSocketExtensions = req.headers['sec-websocket-extensions'];\n const extensions = {};\n\n if (\n this.options.perMessageDeflate &&\n secWebSocketExtensions !== undefined\n ) {\n const perMessageDeflate = new PerMessageDeflate(\n this.options.perMessageDeflate,\n true,\n this.options.maxPayload\n );\n\n try {\n const offers = extension.parse(secWebSocketExtensions);\n\n if (offers[PerMessageDeflate.extensionName]) {\n perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);\n extensions[PerMessageDeflate.extensionName] = perMessageDeflate;\n }\n } catch (err) {\n const message =\n 'Invalid or unacceptable Sec-WebSocket-Extensions header';\n abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);\n return;\n }\n }\n\n //\n // Optionally call external client verification handler.\n //\n if (this.options.verifyClient) {\n const info = {\n origin:\n req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],\n secure: !!(req.socket.authorized || req.socket.encrypted),\n req\n };\n\n if (this.options.verifyClient.length === 2) {\n this.options.verifyClient(info, (verified, code, message, headers) => {\n if (!verified) {\n return abortHandshake(socket, code || 401, message, headers);\n }\n\n this.completeUpgrade(\n extensions,\n key,\n protocols,\n req,\n socket,\n head,\n cb\n );\n });\n return;\n }\n\n if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);\n }\n\n this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);\n }\n\n /**\n * Upgrade the connection to WebSocket.\n *\n * @param {Object} extensions The accepted extensions\n * @param {String} key The value of the `Sec-WebSocket-Key` header\n * @param {Set} protocols The subprotocols\n * @param {http.IncomingMessage} req The request object\n * @param {Duplex} socket The network socket between the server and client\n * @param {Buffer} head The first packet of the upgraded stream\n * @param {Function} cb Callback\n * @throws {Error} If called more than once with the same socket\n * @private\n */\n completeUpgrade(extensions, key, protocols, req, socket, head, cb) {\n //\n // Destroy the socket if the client has already sent a FIN packet.\n //\n if (!socket.readable || !socket.writable) return socket.destroy();\n\n if (socket[kWebSocket]) {\n throw new Error(\n 'server.handleUpgrade() was called more than once with the same ' +\n 'socket, possibly due to a misconfiguration'\n );\n }\n\n if (this._state > RUNNING) return abortHandshake(socket, 503);\n\n const digest = createHash('sha1')\n .update(key + GUID)\n .digest('base64');\n\n const headers = [\n 'HTTP/1.1 101 Switching Protocols',\n 'Upgrade: websocket',\n 'Connection: Upgrade',\n `Sec-WebSocket-Accept: ${digest}`\n ];\n\n const ws = new this.options.WebSocket(null, undefined, this.options);\n\n if (protocols.size) {\n //\n // Optionally call external protocol selection handler.\n //\n const protocol = this.options.handleProtocols\n ? this.options.handleProtocols(protocols, req)\n : protocols.values().next().value;\n\n if (protocol) {\n headers.push(`Sec-WebSocket-Protocol: ${protocol}`);\n ws._protocol = protocol;\n }\n }\n\n if (extensions[PerMessageDeflate.extensionName]) {\n const params = extensions[PerMessageDeflate.extensionName].params;\n const value = extension.format({\n [PerMessageDeflate.extensionName]: [params]\n });\n headers.push(`Sec-WebSocket-Extensions: ${value}`);\n ws._extensions = extensions;\n }\n\n //\n // Allow external modification/inspection of handshake headers.\n //\n this.emit('headers', headers, req);\n\n socket.write(headers.concat('\\r\\n').join('\\r\\n'));\n socket.removeListener('error', socketOnError);\n\n ws.setSocket(socket, head, {\n allowSynchronousEvents: this.options.allowSynchronousEvents,\n maxPayload: this.options.maxPayload,\n skipUTF8Validation: this.options.skipUTF8Validation\n });\n\n if (this.clients) {\n this.clients.add(ws);\n ws.on('close', () => {\n this.clients.delete(ws);\n\n if (this._shouldEmitClose && !this.clients.size) {\n process.nextTick(emitClose, this);\n }\n });\n }\n\n cb(ws, req);\n }\n}\n\nmodule.exports = WebSocketServer;\n\n/**\n * Add event listeners on an `EventEmitter` using a map of \n * pairs.\n *\n * @param {EventEmitter} server The event emitter\n * @param {Object.} map The listeners to add\n * @return {Function} A function that will remove the added listeners when\n * called\n * @private\n */\nfunction addListeners(server, map) {\n for (const event of Object.keys(map)) server.on(event, map[event]);\n\n return function removeListeners() {\n for (const event of Object.keys(map)) {\n server.removeListener(event, map[event]);\n }\n };\n}\n\n/**\n * Emit a `'close'` event on an `EventEmitter`.\n *\n * @param {EventEmitter} server The event emitter\n * @private\n */\nfunction emitClose(server) {\n server._state = CLOSED;\n server.emit('close');\n}\n\n/**\n * Handle socket errors.\n *\n * @private\n */\nfunction socketOnError() {\n this.destroy();\n}\n\n/**\n * Close the connection when preconditions are not fulfilled.\n *\n * @param {Duplex} socket The socket of the upgrade request\n * @param {Number} code The HTTP response status code\n * @param {String} [message] The HTTP response body\n * @param {Object} [headers] Additional HTTP response headers\n * @private\n */\nfunction abortHandshake(socket, code, message, headers) {\n //\n // The socket is writable unless the user destroyed or ended it before calling\n // `server.handleUpgrade()` or in the `verifyClient` function, which is a user\n // error. Handling this does not make much sense as the worst that can happen\n // is that some of the data written by the user might be discarded due to the\n // call to `socket.end()` below, which triggers an `'error'` event that in\n // turn causes the socket to be destroyed.\n //\n message = message || http.STATUS_CODES[code];\n headers = {\n Connection: 'close',\n 'Content-Type': 'text/html',\n 'Content-Length': Buffer.byteLength(message),\n ...headers\n };\n\n socket.once('finish', socket.destroy);\n\n socket.end(\n `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\\r\\n` +\n Object.keys(headers)\n .map((h) => `${h}: ${headers[h]}`)\n .join('\\r\\n') +\n '\\r\\n\\r\\n' +\n message\n );\n}\n\n/**\n * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least\n * one listener for it, otherwise call `abortHandshake()`.\n *\n * @param {WebSocketServer} server The WebSocket server\n * @param {http.IncomingMessage} req The request object\n * @param {Duplex} socket The socket of the upgrade request\n * @param {Number} code The HTTP response status code\n * @param {String} message The HTTP response body\n * @param {Object} [headers] The HTTP response headers\n * @private\n */\nfunction abortHandshakeOrEmitwsClientError(\n server,\n req,\n socket,\n code,\n message,\n headers\n) {\n if (server.listenerCount('wsClientError')) {\n const err = new Error(message);\n Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);\n\n server.emit('wsClientError', err, socket, req);\n } else {\n abortHandshake(socket, code, message, headers);\n }\n}\n", "// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport abstract class _CodeOrName {\n abstract readonly str: string\n abstract readonly names: UsedNames\n abstract toString(): string\n abstract emptyStr(): boolean\n}\n\nexport const IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i\n\nexport class Name extends _CodeOrName {\n readonly str: string\n constructor(s: string) {\n super()\n if (!IDENTIFIER.test(s)) throw new Error(\"CodeGen: name must be a valid identifier\")\n this.str = s\n }\n\n toString(): string {\n return this.str\n }\n\n emptyStr(): boolean {\n return false\n }\n\n get names(): UsedNames {\n return {[this.str]: 1}\n }\n}\n\nexport class _Code extends _CodeOrName {\n readonly _items: readonly CodeItem[]\n private _str?: string\n private _names?: UsedNames\n\n constructor(code: string | readonly CodeItem[]) {\n super()\n this._items = typeof code === \"string\" ? [code] : code\n }\n\n toString(): string {\n return this.str\n }\n\n emptyStr(): boolean {\n if (this._items.length > 1) return false\n const item = this._items[0]\n return item === \"\" || item === '\"\"'\n }\n\n get str(): string {\n return (this._str ??= this._items.reduce((s: string, c: CodeItem) => `${s}${c}`, \"\"))\n }\n\n get names(): UsedNames {\n return (this._names ??= this._items.reduce((names: UsedNames, c) => {\n if (c instanceof Name) names[c.str] = (names[c.str] || 0) + 1\n return names\n }, {}))\n }\n}\n\nexport type CodeItem = Name | string | number | boolean | null\n\nexport type UsedNames = Record\n\nexport type Code = _Code | Name\n\nexport type SafeExpr = Code | number | boolean | null\n\nexport const nil = new _Code(\"\")\n\ntype CodeArg = SafeExpr | string | undefined\n\nexport function _(strs: TemplateStringsArray, ...args: CodeArg[]): _Code {\n const code: CodeItem[] = [strs[0]]\n let i = 0\n while (i < args.length) {\n addCodeArg(code, args[i])\n code.push(strs[++i])\n }\n return new _Code(code)\n}\n\nconst plus = new _Code(\"+\")\n\nexport function str(strs: TemplateStringsArray, ...args: (CodeArg | string[])[]): _Code {\n const expr: CodeItem[] = [safeStringify(strs[0])]\n let i = 0\n while (i < args.length) {\n expr.push(plus)\n addCodeArg(expr, args[i])\n expr.push(plus, safeStringify(strs[++i]))\n }\n optimize(expr)\n return new _Code(expr)\n}\n\nexport function addCodeArg(code: CodeItem[], arg: CodeArg | string[]): void {\n if (arg instanceof _Code) code.push(...arg._items)\n else if (arg instanceof Name) code.push(arg)\n else code.push(interpolate(arg))\n}\n\nfunction optimize(expr: CodeItem[]): void {\n let i = 1\n while (i < expr.length - 1) {\n if (expr[i] === plus) {\n const res = mergeExprItems(expr[i - 1], expr[i + 1])\n if (res !== undefined) {\n expr.splice(i - 1, 3, res)\n continue\n }\n expr[i++] = \"+\"\n }\n i++\n }\n}\n\nfunction mergeExprItems(a: CodeItem, b: CodeItem): CodeItem | undefined {\n if (b === '\"\"') return a\n if (a === '\"\"') return b\n if (typeof a == \"string\") {\n if (b instanceof Name || a[a.length - 1] !== '\"') return\n if (typeof b != \"string\") return `${a.slice(0, -1)}${b}\"`\n if (b[0] === '\"') return a.slice(0, -1) + b.slice(1)\n return\n }\n if (typeof b == \"string\" && b[0] === '\"' && !(a instanceof Name)) return `\"${a}${b.slice(1)}`\n return\n}\n\nexport function strConcat(c1: Code, c2: Code): Code {\n return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`\n}\n\n// TODO do not allow arrays here\nfunction interpolate(x?: string | string[] | number | boolean | null): SafeExpr | string {\n return typeof x == \"number\" || typeof x == \"boolean\" || x === null\n ? x\n : safeStringify(Array.isArray(x) ? x.join(\",\") : x)\n}\n\nexport function stringify(x: unknown): Code {\n return new _Code(safeStringify(x))\n}\n\nexport function safeStringify(x: unknown): string {\n return JSON.stringify(x)\n .replace(/\\u2028/g, \"\\\\u2028\")\n .replace(/\\u2029/g, \"\\\\u2029\")\n}\n\nexport function getProperty(key: Code | string | number): Code {\n return typeof key == \"string\" && IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`\n}\n\n//Does best effort to format the name properly\nexport function getEsmExportName(key: Code | string | number): Code {\n if (typeof key == \"string\" && IDENTIFIER.test(key)) {\n return new _Code(`${key}`)\n }\n throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`)\n}\n\nexport function regexpCode(rx: RegExp): Code {\n return new _Code(rx.toString())\n}\n", "import {_, nil, Code, Name} from \"./code\"\n\ninterface NameGroup {\n prefix: string\n index: number\n}\n\nexport interface NameValue {\n ref: ValueReference // this is the reference to any value that can be referred to from generated code via `globals` var in the closure\n key?: unknown // any key to identify a global to avoid duplicates, if not passed ref is used\n code?: Code // this is the code creating the value needed for standalone code wit_out closure - can be a primitive value, function or import (`require`)\n}\n\nexport type ValueReference = unknown // possibly make CodeGen parameterized type on this type\n\nclass ValueError extends Error {\n readonly value?: NameValue\n constructor(name: ValueScopeName) {\n super(`CodeGen: \"code\" for ${name} not defined`)\n this.value = name.value\n }\n}\n\ninterface ScopeOptions {\n prefixes?: Set\n parent?: Scope\n}\n\ninterface ValueScopeOptions extends ScopeOptions {\n scope: ScopeStore\n es5?: boolean\n lines?: boolean\n}\n\nexport type ScopeStore = Record\n\ntype ScopeValues = {\n [Prefix in string]?: Map\n}\n\nexport type ScopeValueSets = {\n [Prefix in string]?: Set\n}\n\nexport enum UsedValueState {\n Started,\n Completed,\n}\n\nexport type UsedScopeValues = {\n [Prefix in string]?: Map\n}\n\nexport const varKinds = {\n const: new Name(\"const\"),\n let: new Name(\"let\"),\n var: new Name(\"var\"),\n}\n\nexport class Scope {\n protected readonly _names: {[Prefix in string]?: NameGroup} = {}\n protected readonly _prefixes?: Set\n protected readonly _parent?: Scope\n\n constructor({prefixes, parent}: ScopeOptions = {}) {\n this._prefixes = prefixes\n this._parent = parent\n }\n\n toName(nameOrPrefix: Name | string): Name {\n return nameOrPrefix instanceof Name ? nameOrPrefix : this.name(nameOrPrefix)\n }\n\n name(prefix: string): Name {\n return new Name(this._newName(prefix))\n }\n\n protected _newName(prefix: string): string {\n const ng = this._names[prefix] || this._nameGroup(prefix)\n return `${prefix}${ng.index++}`\n }\n\n private _nameGroup(prefix: string): NameGroup {\n if (this._parent?._prefixes?.has(prefix) || (this._prefixes && !this._prefixes.has(prefix))) {\n throw new Error(`CodeGen: prefix \"${prefix}\" is not allowed in this scope`)\n }\n return (this._names[prefix] = {prefix, index: 0})\n }\n}\n\ninterface ScopePath {\n property: string\n itemIndex: number\n}\n\nexport class ValueScopeName extends Name {\n readonly prefix: string\n value?: NameValue\n scopePath?: Code\n\n constructor(prefix: string, nameStr: string) {\n super(nameStr)\n this.prefix = prefix\n }\n\n setValue(value: NameValue, {property, itemIndex}: ScopePath): void {\n this.value = value\n this.scopePath = _`.${new Name(property)}[${itemIndex}]`\n }\n}\n\ninterface VSOptions extends ValueScopeOptions {\n _n: Code\n}\n\nconst line = _`\\n`\n\nexport class ValueScope extends Scope {\n protected readonly _values: ScopeValues = {}\n protected readonly _scope: ScopeStore\n readonly opts: VSOptions\n\n constructor(opts: ValueScopeOptions) {\n super(opts)\n this._scope = opts.scope\n this.opts = {...opts, _n: opts.lines ? line : nil}\n }\n\n get(): ScopeStore {\n return this._scope\n }\n\n name(prefix: string): ValueScopeName {\n return new ValueScopeName(prefix, this._newName(prefix))\n }\n\n value(nameOrPrefix: ValueScopeName | string, value: NameValue): ValueScopeName {\n if (value.ref === undefined) throw new Error(\"CodeGen: ref must be passed in value\")\n const name = this.toName(nameOrPrefix) as ValueScopeName\n const {prefix} = name\n const valueKey = value.key ?? value.ref\n let vs = this._values[prefix]\n if (vs) {\n const _name = vs.get(valueKey)\n if (_name) return _name\n } else {\n vs = this._values[prefix] = new Map()\n }\n vs.set(valueKey, name)\n\n const s = this._scope[prefix] || (this._scope[prefix] = [])\n const itemIndex = s.length\n s[itemIndex] = value.ref\n name.setValue(value, {property: prefix, itemIndex})\n return name\n }\n\n getValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined {\n const vs = this._values[prefix]\n if (!vs) return\n return vs.get(keyOrRef)\n }\n\n scopeRefs(scopeName: Name, values: ScopeValues | ScopeValueSets = this._values): Code {\n return this._reduceValues(values, (name: ValueScopeName) => {\n if (name.scopePath === undefined) throw new Error(`CodeGen: name \"${name}\" has no value`)\n return _`${scopeName}${name.scopePath}`\n })\n }\n\n scopeCode(\n values: ScopeValues | ScopeValueSets = this._values,\n usedValues?: UsedScopeValues,\n getCode?: (n: ValueScopeName) => Code | undefined\n ): Code {\n return this._reduceValues(\n values,\n (name: ValueScopeName) => {\n if (name.value === undefined) throw new Error(`CodeGen: name \"${name}\" has no value`)\n return name.value.code\n },\n usedValues,\n getCode\n )\n }\n\n private _reduceValues(\n values: ScopeValues | ScopeValueSets,\n valueCode: (n: ValueScopeName) => Code | undefined,\n usedValues: UsedScopeValues = {},\n getCode?: (n: ValueScopeName) => Code | undefined\n ): Code {\n let code: Code = nil\n for (const prefix in values) {\n const vs = values[prefix]\n if (!vs) continue\n const nameSet = (usedValues[prefix] = usedValues[prefix] || new Map())\n vs.forEach((name: ValueScopeName) => {\n if (nameSet.has(name)) return\n nameSet.set(name, UsedValueState.Started)\n let c = valueCode(name)\n if (c) {\n const def = this.opts.es5 ? varKinds.var : varKinds.const\n code = _`${code}${def} ${name} = ${c};${this.opts._n}`\n } else if ((c = getCode?.(name))) {\n code = _`${code}${c}${this.opts._n}`\n } else {\n throw new ValueError(name)\n }\n nameSet.set(name, UsedValueState.Completed)\n })\n }\n return code\n }\n}\n", "import type {ScopeValueSets, NameValue, ValueScope, ValueScopeName} from \"./scope\"\nimport {_, nil, _Code, Code, Name, UsedNames, CodeItem, addCodeArg, _CodeOrName} from \"./code\"\nimport {Scope, varKinds} from \"./scope\"\n\nexport {_, str, strConcat, nil, getProperty, stringify, regexpCode, Name, Code} from \"./code\"\nexport {Scope, ScopeStore, ValueScope, ValueScopeName, ScopeValueSets, varKinds} from \"./scope\"\n\n// type for expressions that can be safely inserted in code without quotes\nexport type SafeExpr = Code | number | boolean | null\n\n// type that is either Code of function that adds code to CodeGen instance using its methods\nexport type Block = Code | (() => void)\n\nexport const operators = {\n GT: new _Code(\">\"),\n GTE: new _Code(\">=\"),\n LT: new _Code(\"<\"),\n LTE: new _Code(\"<=\"),\n EQ: new _Code(\"===\"),\n NEQ: new _Code(\"!==\"),\n NOT: new _Code(\"!\"),\n OR: new _Code(\"||\"),\n AND: new _Code(\"&&\"),\n ADD: new _Code(\"+\"),\n}\n\nabstract class Node {\n abstract readonly names: UsedNames\n\n optimizeNodes(): this | ChildNode | ChildNode[] | undefined {\n return this\n }\n\n optimizeNames(_names: UsedNames, _constants: Constants): this | undefined {\n return this\n }\n\n // get count(): number {\n // return 1\n // }\n}\n\nclass Def extends Node {\n constructor(\n private readonly varKind: Name,\n private readonly name: Name,\n private rhs?: SafeExpr\n ) {\n super()\n }\n\n render({es5, _n}: CGOptions): string {\n const varKind = es5 ? varKinds.var : this.varKind\n const rhs = this.rhs === undefined ? \"\" : ` = ${this.rhs}`\n return `${varKind} ${this.name}${rhs};` + _n\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this | undefined {\n if (!names[this.name.str]) return\n if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants)\n return this\n }\n\n get names(): UsedNames {\n return this.rhs instanceof _CodeOrName ? this.rhs.names : {}\n }\n}\n\nclass Assign extends Node {\n constructor(\n readonly lhs: Code,\n public rhs: SafeExpr,\n private readonly sideEffects?: boolean\n ) {\n super()\n }\n\n render({_n}: CGOptions): string {\n return `${this.lhs} = ${this.rhs};` + _n\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this | undefined {\n if (this.lhs instanceof Name && !names[this.lhs.str] && !this.sideEffects) return\n this.rhs = optimizeExpr(this.rhs, names, constants)\n return this\n }\n\n get names(): UsedNames {\n const names = this.lhs instanceof Name ? {} : {...this.lhs.names}\n return addExprNames(names, this.rhs)\n }\n}\n\nclass AssignOp extends Assign {\n constructor(\n lhs: Code,\n private readonly op: Code,\n rhs: SafeExpr,\n sideEffects?: boolean\n ) {\n super(lhs, rhs, sideEffects)\n }\n\n render({_n}: CGOptions): string {\n return `${this.lhs} ${this.op}= ${this.rhs};` + _n\n }\n}\n\nclass Label extends Node {\n readonly names: UsedNames = {}\n constructor(readonly label: Name) {\n super()\n }\n\n render({_n}: CGOptions): string {\n return `${this.label}:` + _n\n }\n}\n\nclass Break extends Node {\n readonly names: UsedNames = {}\n constructor(readonly label?: Code) {\n super()\n }\n\n render({_n}: CGOptions): string {\n const label = this.label ? ` ${this.label}` : \"\"\n return `break${label};` + _n\n }\n}\n\nclass Throw extends Node {\n constructor(readonly error: Code) {\n super()\n }\n\n render({_n}: CGOptions): string {\n return `throw ${this.error};` + _n\n }\n\n get names(): UsedNames {\n return this.error.names\n }\n}\n\nclass AnyCode extends Node {\n constructor(private code: SafeExpr) {\n super()\n }\n\n render({_n}: CGOptions): string {\n return `${this.code};` + _n\n }\n\n optimizeNodes(): this | undefined {\n return `${this.code}` ? this : undefined\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this {\n this.code = optimizeExpr(this.code, names, constants)\n return this\n }\n\n get names(): UsedNames {\n return this.code instanceof _CodeOrName ? this.code.names : {}\n }\n}\n\nabstract class ParentNode extends Node {\n constructor(readonly nodes: ChildNode[] = []) {\n super()\n }\n\n render(opts: CGOptions): string {\n return this.nodes.reduce((code, n) => code + n.render(opts), \"\")\n }\n\n optimizeNodes(): this | ChildNode | ChildNode[] | undefined {\n const {nodes} = this\n let i = nodes.length\n while (i--) {\n const n = nodes[i].optimizeNodes()\n if (Array.isArray(n)) nodes.splice(i, 1, ...n)\n else if (n) nodes[i] = n\n else nodes.splice(i, 1)\n }\n return nodes.length > 0 ? this : undefined\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this | undefined {\n const {nodes} = this\n let i = nodes.length\n while (i--) {\n // iterating backwards improves 1-pass optimization\n const n = nodes[i]\n if (n.optimizeNames(names, constants)) continue\n subtractNames(names, n.names)\n nodes.splice(i, 1)\n }\n return nodes.length > 0 ? this : undefined\n }\n\n get names(): UsedNames {\n return this.nodes.reduce((names: UsedNames, n) => addNames(names, n.names), {})\n }\n\n // get count(): number {\n // return this.nodes.reduce((c, n) => c + n.count, 1)\n // }\n}\n\nabstract class BlockNode extends ParentNode {\n render(opts: CGOptions): string {\n return \"{\" + opts._n + super.render(opts) + \"}\" + opts._n\n }\n}\n\nclass Root extends ParentNode {}\n\nclass Else extends BlockNode {\n static readonly kind = \"else\"\n}\n\nclass If extends BlockNode {\n static readonly kind = \"if\"\n else?: If | Else\n constructor(\n private condition: Code | boolean,\n nodes?: ChildNode[]\n ) {\n super(nodes)\n }\n\n render(opts: CGOptions): string {\n let code = `if(${this.condition})` + super.render(opts)\n if (this.else) code += \"else \" + this.else.render(opts)\n return code\n }\n\n optimizeNodes(): If | ChildNode[] | undefined {\n super.optimizeNodes()\n const cond = this.condition\n if (cond === true) return this.nodes // else is ignored here\n let e = this.else\n if (e) {\n const ns = e.optimizeNodes()\n e = this.else = Array.isArray(ns) ? new Else(ns) : (ns as Else | undefined)\n }\n if (e) {\n if (cond === false) return e instanceof If ? e : e.nodes\n if (this.nodes.length) return this\n return new If(not(cond), e instanceof If ? [e] : e.nodes)\n }\n if (cond === false || !this.nodes.length) return undefined\n return this\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this | undefined {\n this.else = this.else?.optimizeNames(names, constants)\n if (!(super.optimizeNames(names, constants) || this.else)) return\n this.condition = optimizeExpr(this.condition, names, constants)\n return this\n }\n\n get names(): UsedNames {\n const names = super.names\n addExprNames(names, this.condition)\n if (this.else) addNames(names, this.else.names)\n return names\n }\n\n // get count(): number {\n // return super.count + (this.else?.count || 0)\n // }\n}\n\nabstract class For extends BlockNode {\n static readonly kind = \"for\"\n}\n\nclass ForLoop extends For {\n constructor(private iteration: Code) {\n super()\n }\n\n render(opts: CGOptions): string {\n return `for(${this.iteration})` + super.render(opts)\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this | undefined {\n if (!super.optimizeNames(names, constants)) return\n this.iteration = optimizeExpr(this.iteration, names, constants)\n return this\n }\n\n get names(): UsedNames {\n return addNames(super.names, this.iteration.names)\n }\n}\n\nclass ForRange extends For {\n constructor(\n private readonly varKind: Name,\n private readonly name: Name,\n private readonly from: SafeExpr,\n private readonly to: SafeExpr\n ) {\n super()\n }\n\n render(opts: CGOptions): string {\n const varKind = opts.es5 ? varKinds.var : this.varKind\n const {name, from, to} = this\n return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts)\n }\n\n get names(): UsedNames {\n const names = addExprNames(super.names, this.from)\n return addExprNames(names, this.to)\n }\n}\n\nclass ForIter extends For {\n constructor(\n private readonly loop: \"of\" | \"in\",\n private readonly varKind: Name,\n private readonly name: Name,\n private iterable: Code\n ) {\n super()\n }\n\n render(opts: CGOptions): string {\n return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts)\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this | undefined {\n if (!super.optimizeNames(names, constants)) return\n this.iterable = optimizeExpr(this.iterable, names, constants)\n return this\n }\n\n get names(): UsedNames {\n return addNames(super.names, this.iterable.names)\n }\n}\n\nclass Func extends BlockNode {\n static readonly kind = \"func\"\n constructor(\n public name: Name,\n public args: Code,\n public async?: boolean\n ) {\n super()\n }\n\n render(opts: CGOptions): string {\n const _async = this.async ? \"async \" : \"\"\n return `${_async}function ${this.name}(${this.args})` + super.render(opts)\n }\n}\n\nclass Return extends ParentNode {\n static readonly kind = \"return\"\n\n render(opts: CGOptions): string {\n return \"return \" + super.render(opts)\n }\n}\n\nclass Try extends BlockNode {\n catch?: Catch\n finally?: Finally\n\n render(opts: CGOptions): string {\n let code = \"try\" + super.render(opts)\n if (this.catch) code += this.catch.render(opts)\n if (this.finally) code += this.finally.render(opts)\n return code\n }\n\n optimizeNodes(): this {\n super.optimizeNodes()\n this.catch?.optimizeNodes() as Catch | undefined\n this.finally?.optimizeNodes() as Finally | undefined\n return this\n }\n\n optimizeNames(names: UsedNames, constants: Constants): this {\n super.optimizeNames(names, constants)\n this.catch?.optimizeNames(names, constants)\n this.finally?.optimizeNames(names, constants)\n return this\n }\n\n get names(): UsedNames {\n const names = super.names\n if (this.catch) addNames(names, this.catch.names)\n if (this.finally) addNames(names, this.finally.names)\n return names\n }\n\n // get count(): number {\n // return super.count + (this.catch?.count || 0) + (this.finally?.count || 0)\n // }\n}\n\nclass Catch extends BlockNode {\n static readonly kind = \"catch\"\n constructor(readonly error: Name) {\n super()\n }\n\n render(opts: CGOptions): string {\n return `catch(${this.error})` + super.render(opts)\n }\n}\n\nclass Finally extends BlockNode {\n static readonly kind = \"finally\"\n render(opts: CGOptions): string {\n return \"finally\" + super.render(opts)\n }\n}\n\ntype StartBlockNode = If | For | Func | Return | Try\n\ntype LeafNode = Def | Assign | Label | Break | Throw | AnyCode\n\ntype ChildNode = StartBlockNode | LeafNode\n\ntype EndBlockNodeType =\n | typeof If\n | typeof Else\n | typeof For\n | typeof Func\n | typeof Return\n | typeof Catch\n | typeof Finally\n\ntype Constants = Record\n\nexport interface CodeGenOptions {\n es5?: boolean\n lines?: boolean\n ownProperties?: boolean\n}\n\ninterface CGOptions extends CodeGenOptions {\n _n: \"\\n\" | \"\"\n}\n\nexport class CodeGen {\n readonly _scope: Scope\n readonly _extScope: ValueScope\n readonly _values: ScopeValueSets = {}\n private readonly _nodes: ParentNode[]\n private readonly _blockStarts: number[] = []\n private readonly _constants: Constants = {}\n private readonly opts: CGOptions\n\n constructor(extScope: ValueScope, opts: CodeGenOptions = {}) {\n this.opts = {...opts, _n: opts.lines ? \"\\n\" : \"\"}\n this._extScope = extScope\n this._scope = new Scope({parent: extScope})\n this._nodes = [new Root()]\n }\n\n toString(): string {\n return this._root.render(this.opts)\n }\n\n // returns unique name in the internal scope\n name(prefix: string): Name {\n return this._scope.name(prefix)\n }\n\n // reserves unique name in the external scope\n scopeName(prefix: string): ValueScopeName {\n return this._extScope.name(prefix)\n }\n\n // reserves unique name in the external scope and assigns value to it\n scopeValue(prefixOrName: ValueScopeName | string, value: NameValue): Name {\n const name = this._extScope.value(prefixOrName, value)\n const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set())\n vs.add(name)\n return name\n }\n\n getScopeValue(prefix: string, keyOrRef: unknown): ValueScopeName | undefined {\n return this._extScope.getValue(prefix, keyOrRef)\n }\n\n // return code that assigns values in the external scope to the names that are used internally\n // (same names that were returned by gen.scopeName or gen.scopeValue)\n scopeRefs(scopeName: Name): Code {\n return this._extScope.scopeRefs(scopeName, this._values)\n }\n\n scopeCode(): Code {\n return this._extScope.scopeCode(this._values)\n }\n\n private _def(\n varKind: Name,\n nameOrPrefix: Name | string,\n rhs?: SafeExpr,\n constant?: boolean\n ): Name {\n const name = this._scope.toName(nameOrPrefix)\n if (rhs !== undefined && constant) this._constants[name.str] = rhs\n this._leafNode(new Def(varKind, name, rhs))\n return name\n }\n\n // `const` declaration (`var` in es5 mode)\n const(nameOrPrefix: Name | string, rhs: SafeExpr, _constant?: boolean): Name {\n return this._def(varKinds.const, nameOrPrefix, rhs, _constant)\n }\n\n // `let` declaration with optional assignment (`var` in es5 mode)\n let(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name {\n return this._def(varKinds.let, nameOrPrefix, rhs, _constant)\n }\n\n // `var` declaration with optional assignment\n var(nameOrPrefix: Name | string, rhs?: SafeExpr, _constant?: boolean): Name {\n return this._def(varKinds.var, nameOrPrefix, rhs, _constant)\n }\n\n // assignment code\n assign(lhs: Code, rhs: SafeExpr, sideEffects?: boolean): CodeGen {\n return this._leafNode(new Assign(lhs, rhs, sideEffects))\n }\n\n // `+=` code\n add(lhs: Code, rhs: SafeExpr): CodeGen {\n return this._leafNode(new AssignOp(lhs, operators.ADD, rhs))\n }\n\n // appends passed SafeExpr to code or executes Block\n code(c: Block | SafeExpr): CodeGen {\n if (typeof c == \"function\") c()\n else if (c !== nil) this._leafNode(new AnyCode(c))\n return this\n }\n\n // returns code for object literal for the passed argument list of key-value pairs\n object(...keyValues: [Name | string, SafeExpr | string][]): _Code {\n const code: CodeItem[] = [\"{\"]\n for (const [key, value] of keyValues) {\n if (code.length > 1) code.push(\",\")\n code.push(key)\n if (key !== value || this.opts.es5) {\n code.push(\":\")\n addCodeArg(code, value)\n }\n }\n code.push(\"}\")\n return new _Code(code)\n }\n\n // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)\n if(condition: Code | boolean, thenBody?: Block, elseBody?: Block): CodeGen {\n this._blockNode(new If(condition))\n\n if (thenBody && elseBody) {\n this.code(thenBody).else().code(elseBody).endIf()\n } else if (thenBody) {\n this.code(thenBody).endIf()\n } else if (elseBody) {\n throw new Error('CodeGen: \"else\" body without \"then\" body')\n }\n return this\n }\n\n // `else if` clause - invalid without `if` or after `else` clauses\n elseIf(condition: Code | boolean): CodeGen {\n return this._elseNode(new If(condition))\n }\n\n // `else` clause - only valid after `if` or `else if` clauses\n else(): CodeGen {\n return this._elseNode(new Else())\n }\n\n // end `if` statement (needed if gen.if was used only with condition)\n endIf(): CodeGen {\n return this._endBlockNode(If, Else)\n }\n\n private _for(node: For, forBody?: Block): CodeGen {\n this._blockNode(node)\n if (forBody) this.code(forBody).endFor()\n return this\n }\n\n // a generic `for` clause (or statement if `forBody` is passed)\n for(iteration: Code, forBody?: Block): CodeGen {\n return this._for(new ForLoop(iteration), forBody)\n }\n\n // `for` statement for a range of values\n forRange(\n nameOrPrefix: Name | string,\n from: SafeExpr,\n to: SafeExpr,\n forBody: (index: Name) => void,\n varKind: Code = this.opts.es5 ? varKinds.var : varKinds.let\n ): CodeGen {\n const name = this._scope.toName(nameOrPrefix)\n return this._for(new ForRange(varKind, name, from, to), () => forBody(name))\n }\n\n // `for-of` statement (in es5 mode replace with a normal for loop)\n forOf(\n nameOrPrefix: Name | string,\n iterable: Code,\n forBody: (item: Name) => void,\n varKind: Code = varKinds.const\n ): CodeGen {\n const name = this._scope.toName(nameOrPrefix)\n if (this.opts.es5) {\n const arr = iterable instanceof Name ? iterable : this.var(\"_arr\", iterable)\n return this.forRange(\"_i\", 0, _`${arr}.length`, (i) => {\n this.var(name, _`${arr}[${i}]`)\n forBody(name)\n })\n }\n return this._for(new ForIter(\"of\", varKind, name, iterable), () => forBody(name))\n }\n\n // `for-in` statement.\n // With option `ownProperties` replaced with a `for-of` loop for object keys\n forIn(\n nameOrPrefix: Name | string,\n obj: Code,\n forBody: (item: Name) => void,\n varKind: Code = this.opts.es5 ? varKinds.var : varKinds.const\n ): CodeGen {\n if (this.opts.ownProperties) {\n return this.forOf(nameOrPrefix, _`Object.keys(${obj})`, forBody)\n }\n const name = this._scope.toName(nameOrPrefix)\n return this._for(new ForIter(\"in\", varKind, name, obj), () => forBody(name))\n }\n\n // end `for` loop\n endFor(): CodeGen {\n return this._endBlockNode(For)\n }\n\n // `label` statement\n label(label: Name): CodeGen {\n return this._leafNode(new Label(label))\n }\n\n // `break` statement\n break(label?: Code): CodeGen {\n return this._leafNode(new Break(label))\n }\n\n // `return` statement\n return(value: Block | SafeExpr): CodeGen {\n const node = new Return()\n this._blockNode(node)\n this.code(value)\n if (node.nodes.length !== 1) throw new Error('CodeGen: \"return\" should have one node')\n return this._endBlockNode(Return)\n }\n\n // `try` statement\n try(tryBody: Block, catchCode?: (e: Name) => void, finallyCode?: Block): CodeGen {\n if (!catchCode && !finallyCode) throw new Error('CodeGen: \"try\" without \"catch\" and \"finally\"')\n const node = new Try()\n this._blockNode(node)\n this.code(tryBody)\n if (catchCode) {\n const error = this.name(\"e\")\n this._currNode = node.catch = new Catch(error)\n catchCode(error)\n }\n if (finallyCode) {\n this._currNode = node.finally = new Finally()\n this.code(finallyCode)\n }\n return this._endBlockNode(Catch, Finally)\n }\n\n // `throw` statement\n throw(error: Code): CodeGen {\n return this._leafNode(new Throw(error))\n }\n\n // start self-balancing block\n block(body?: Block, nodeCount?: number): CodeGen {\n this._blockStarts.push(this._nodes.length)\n if (body) this.code(body).endBlock(nodeCount)\n return this\n }\n\n // end the current self-balancing block\n endBlock(nodeCount?: number): CodeGen {\n const len = this._blockStarts.pop()\n if (len === undefined) throw new Error(\"CodeGen: not in self-balancing block\")\n const toClose = this._nodes.length - len\n if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) {\n throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`)\n }\n this._nodes.length = len\n return this\n }\n\n // `function` heading (or definition if funcBody is passed)\n func(name: Name, args: Code = nil, async?: boolean, funcBody?: Block): CodeGen {\n this._blockNode(new Func(name, args, async))\n if (funcBody) this.code(funcBody).endFunc()\n return this\n }\n\n // end function definition\n endFunc(): CodeGen {\n return this._endBlockNode(Func)\n }\n\n optimize(n = 1): void {\n while (n-- > 0) {\n this._root.optimizeNodes()\n this._root.optimizeNames(this._root.names, this._constants)\n }\n }\n\n private _leafNode(node: LeafNode): CodeGen {\n this._currNode.nodes.push(node)\n return this\n }\n\n private _blockNode(node: StartBlockNode): void {\n this._currNode.nodes.push(node)\n this._nodes.push(node)\n }\n\n private _endBlockNode(N1: EndBlockNodeType, N2?: EndBlockNodeType): CodeGen {\n const n = this._currNode\n if (n instanceof N1 || (N2 && n instanceof N2)) {\n this._nodes.pop()\n return this\n }\n throw new Error(`CodeGen: not in block \"${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}\"`)\n }\n\n private _elseNode(node: If | Else): CodeGen {\n const n = this._currNode\n if (!(n instanceof If)) {\n throw new Error('CodeGen: \"else\" without \"if\"')\n }\n this._currNode = n.else = node\n return this\n }\n\n private get _root(): Root {\n return this._nodes[0] as Root\n }\n\n private get _currNode(): ParentNode {\n const ns = this._nodes\n return ns[ns.length - 1]\n }\n\n private set _currNode(node: ParentNode) {\n const ns = this._nodes\n ns[ns.length - 1] = node\n }\n\n // get nodeCount(): number {\n // return this._root.count\n // }\n}\n\nfunction addNames(names: UsedNames, from: UsedNames): UsedNames {\n for (const n in from) names[n] = (names[n] || 0) + (from[n] || 0)\n return names\n}\n\nfunction addExprNames(names: UsedNames, from: SafeExpr): UsedNames {\n return from instanceof _CodeOrName ? addNames(names, from.names) : names\n}\n\nfunction optimizeExpr(expr: T, names: UsedNames, constants: Constants): T\nfunction optimizeExpr(expr: SafeExpr, names: UsedNames, constants: Constants): SafeExpr {\n if (expr instanceof Name) return replaceName(expr)\n if (!canOptimize(expr)) return expr\n return new _Code(\n expr._items.reduce((items: CodeItem[], c: SafeExpr | string) => {\n if (c instanceof Name) c = replaceName(c)\n if (c instanceof _Code) items.push(...c._items)\n else items.push(c)\n return items\n }, [])\n )\n\n function replaceName(n: Name): SafeExpr {\n const c = constants[n.str]\n if (c === undefined || names[n.str] !== 1) return n\n delete names[n.str]\n return c\n }\n\n function canOptimize(e: SafeExpr): e is _Code {\n return (\n e instanceof _Code &&\n e._items.some(\n (c) => c instanceof Name && names[c.str] === 1 && constants[c.str] !== undefined\n )\n )\n }\n}\n\nfunction subtractNames(names: UsedNames, from: UsedNames): void {\n for (const n in from) names[n] = (names[n] || 0) - (from[n] || 0)\n}\n\nexport function not(x: T): T\nexport function not(x: Code | SafeExpr): Code | SafeExpr {\n return typeof x == \"boolean\" || typeof x == \"number\" || x === null ? !x : _`!${par(x)}`\n}\n\nconst andCode = mappend(operators.AND)\n\n// boolean AND (&&) expression with the passed arguments\nexport function and(...args: Code[]): Code {\n return args.reduce(andCode)\n}\n\nconst orCode = mappend(operators.OR)\n\n// boolean OR (||) expression with the passed arguments\nexport function or(...args: Code[]): Code {\n return args.reduce(orCode)\n}\n\ntype MAppend = (x: Code, y: Code) => Code\n\nfunction mappend(op: Code): MAppend {\n return (x, y) => (x === nil ? y : y === nil ? x : _`${par(x)} ${op} ${par(y)}`)\n}\n\nfunction par(x: Code): Code {\n return x instanceof Name ? x : _`(${x})`\n}\n", "import type {AnySchema, EvaluatedProperties, EvaluatedItems} from \"../types\"\nimport type {SchemaCxt, SchemaObjCxt} from \".\"\nimport {_, getProperty, Code, Name, CodeGen} from \"./codegen\"\nimport {_Code} from \"./codegen/code\"\nimport type {Rule, ValidationRules} from \"./rules\"\n\n// TODO refactor to use Set\nexport function toHash(arr: T[]): {[K in T]?: true} {\n const hash: {[K in T]?: true} = {}\n for (const item of arr) hash[item] = true\n return hash\n}\n\nexport function alwaysValidSchema(it: SchemaCxt, schema: AnySchema): boolean | void {\n if (typeof schema == \"boolean\") return schema\n if (Object.keys(schema).length === 0) return true\n checkUnknownRules(it, schema)\n return !schemaHasRules(schema, it.self.RULES.all)\n}\n\nexport function checkUnknownRules(it: SchemaCxt, schema: AnySchema = it.schema): void {\n const {opts, self} = it\n if (!opts.strictSchema) return\n if (typeof schema === \"boolean\") return\n const rules = self.RULES.keywords\n for (const key in schema) {\n if (!rules[key]) checkStrictMode(it, `unknown keyword: \"${key}\"`)\n }\n}\n\nexport function schemaHasRules(\n schema: AnySchema,\n rules: {[Key in string]?: boolean | Rule}\n): boolean {\n if (typeof schema == \"boolean\") return !schema\n for (const key in schema) if (rules[key]) return true\n return false\n}\n\nexport function schemaHasRulesButRef(schema: AnySchema, RULES: ValidationRules): boolean {\n if (typeof schema == \"boolean\") return !schema\n for (const key in schema) if (key !== \"$ref\" && RULES.all[key]) return true\n return false\n}\n\nexport function schemaRefOrVal(\n {topSchemaRef, schemaPath}: SchemaObjCxt,\n schema: unknown,\n keyword: string,\n $data?: string | false\n): Code | number | boolean {\n if (!$data) {\n if (typeof schema == \"number\" || typeof schema == \"boolean\") return schema\n if (typeof schema == \"string\") return _`${schema}`\n }\n return _`${topSchemaRef}${schemaPath}${getProperty(keyword)}`\n}\n\nexport function unescapeFragment(str: string): string {\n return unescapeJsonPointer(decodeURIComponent(str))\n}\n\nexport function escapeFragment(str: string | number): string {\n return encodeURIComponent(escapeJsonPointer(str))\n}\n\nexport function escapeJsonPointer(str: string | number): string {\n if (typeof str == \"number\") return `${str}`\n return str.replace(/~/g, \"~0\").replace(/\\//g, \"~1\")\n}\n\nexport function unescapeJsonPointer(str: string): string {\n return str.replace(/~1/g, \"/\").replace(/~0/g, \"~\")\n}\n\nexport function eachItem(xs: T | T[], f: (x: T) => void): void {\n if (Array.isArray(xs)) {\n for (const x of xs) f(x)\n } else {\n f(xs)\n }\n}\n\ntype SomeEvaluated = EvaluatedProperties | EvaluatedItems\n\ntype MergeEvaluatedFunc = (\n gen: CodeGen,\n from: Name | T,\n to: Name | Exclude | undefined,\n toName?: typeof Name\n) => Name | T\n\ninterface MakeMergeFuncArgs {\n mergeNames: (gen: CodeGen, from: Name, to: Name) => void\n mergeToName: (gen: CodeGen, from: T, to: Name) => void\n mergeValues: (from: T, to: Exclude) => T\n resultToName: (gen: CodeGen, res?: T) => Name\n}\n\nfunction makeMergeEvaluated({\n mergeNames,\n mergeToName,\n mergeValues,\n resultToName,\n}: MakeMergeFuncArgs): MergeEvaluatedFunc {\n return (gen, from, to, toName) => {\n const res =\n to === undefined\n ? from\n : to instanceof Name\n ? (from instanceof Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to)\n : from instanceof Name\n ? (mergeToName(gen, to, from), from)\n : mergeValues(from, to)\n return toName === Name && !(res instanceof Name) ? resultToName(gen, res) : res\n }\n}\n\ninterface MergeEvaluated {\n props: MergeEvaluatedFunc\n items: MergeEvaluatedFunc\n}\n\nexport const mergeEvaluated: MergeEvaluated = {\n props: makeMergeEvaluated({\n mergeNames: (gen, from, to) =>\n gen.if(_`${to} !== true && ${from} !== undefined`, () => {\n gen.if(\n _`${from} === true`,\n () => gen.assign(to, true),\n () => gen.assign(to, _`${to} || {}`).code(_`Object.assign(${to}, ${from})`)\n )\n }),\n mergeToName: (gen, from, to) =>\n gen.if(_`${to} !== true`, () => {\n if (from === true) {\n gen.assign(to, true)\n } else {\n gen.assign(to, _`${to} || {}`)\n setEvaluated(gen, to, from)\n }\n }),\n mergeValues: (from, to) => (from === true ? true : {...from, ...to}),\n resultToName: evaluatedPropsToName,\n }),\n items: makeMergeEvaluated({\n mergeNames: (gen, from, to) =>\n gen.if(_`${to} !== true && ${from} !== undefined`, () =>\n gen.assign(to, _`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)\n ),\n mergeToName: (gen, from, to) =>\n gen.if(_`${to} !== true`, () =>\n gen.assign(to, from === true ? true : _`${to} > ${from} ? ${to} : ${from}`)\n ),\n mergeValues: (from, to) => (from === true ? true : Math.max(from, to)),\n resultToName: (gen, items) => gen.var(\"items\", items),\n }),\n}\n\nexport function evaluatedPropsToName(gen: CodeGen, ps?: EvaluatedProperties): Name {\n if (ps === true) return gen.var(\"props\", true)\n const props = gen.var(\"props\", _`{}`)\n if (ps !== undefined) setEvaluated(gen, props, ps)\n return props\n}\n\nexport function setEvaluated(gen: CodeGen, props: Name, ps: {[K in string]?: true}): void {\n Object.keys(ps).forEach((p) => gen.assign(_`${props}${getProperty(p)}`, true))\n}\n\nconst snippets: {[S in string]?: _Code} = {}\n\nexport function useFunc(gen: CodeGen, f: {code: string}): Name {\n return gen.scopeValue(\"func\", {\n ref: f,\n code: snippets[f.code] || (snippets[f.code] = new _Code(f.code)),\n })\n}\n\nexport enum Type {\n Num,\n Str,\n}\n\nexport function getErrorPath(\n dataProp: Name | string | number,\n dataPropType?: Type,\n jsPropertySyntax?: boolean\n): Code | string {\n // let path\n if (dataProp instanceof Name) {\n const isNumber = dataPropType === Type.Num\n return jsPropertySyntax\n ? isNumber\n ? _`\"[\" + ${dataProp} + \"]\"`\n : _`\"['\" + ${dataProp} + \"']\"`\n : isNumber\n ? _`\"/\" + ${dataProp}`\n : _`\"/\" + ${dataProp}.replace(/~/g, \"~0\").replace(/\\\\//g, \"~1\")` // TODO maybe use global escapePointer\n }\n return jsPropertySyntax ? getProperty(dataProp).toString() : \"/\" + escapeJsonPointer(dataProp)\n}\n\nexport function checkStrictMode(\n it: SchemaCxt,\n msg: string,\n mode: boolean | \"log\" = it.opts.strictSchema\n): void {\n if (!mode) return\n msg = `strict mode: ${msg}`\n if (mode === true) throw new Error(msg)\n it.self.logger.warn(msg)\n}\n", "import {Name} from \"./codegen\"\n\nconst names = {\n // validation function arguments\n data: new Name(\"data\"), // data passed to validation function\n // args passed from referencing schema\n valCxt: new Name(\"valCxt\"), // validation/data context - should not be used directly, it is destructured to the names below\n instancePath: new Name(\"instancePath\"),\n parentData: new Name(\"parentData\"),\n parentDataProperty: new Name(\"parentDataProperty\"),\n rootData: new Name(\"rootData\"), // root data - same as the data passed to the first/top validation function\n dynamicAnchors: new Name(\"dynamicAnchors\"), // used to support recursiveRef and dynamicRef\n // function scoped variables\n vErrors: new Name(\"vErrors\"), // null or array of validation errors\n errors: new Name(\"errors\"), // counter of validation errors\n this: new Name(\"this\"),\n // \"globals\"\n self: new Name(\"self\"),\n scope: new Name(\"scope\"),\n // JTD serialize/parse name for JSON string and position\n json: new Name(\"json\"),\n jsonPos: new Name(\"jsonPos\"),\n jsonLen: new Name(\"jsonLen\"),\n jsonPart: new Name(\"jsonPart\"),\n}\n\nexport default names\n", "import type {KeywordErrorCxt, KeywordErrorDefinition} from \"../types\"\nimport type {SchemaCxt} from \"./index\"\nimport {CodeGen, _, str, strConcat, Code, Name} from \"./codegen\"\nimport {SafeExpr} from \"./codegen/code\"\nimport {getErrorPath, Type} from \"./util\"\nimport N from \"./names\"\n\nexport const keywordError: KeywordErrorDefinition = {\n message: ({keyword}) => str`must pass \"${keyword}\" keyword validation`,\n}\n\nexport const keyword$DataError: KeywordErrorDefinition = {\n message: ({keyword, schemaType}) =>\n schemaType\n ? str`\"${keyword}\" keyword must be ${schemaType} ($data)`\n : str`\"${keyword}\" keyword is invalid ($data)`,\n}\n\nexport interface ErrorPaths {\n instancePath?: Code\n schemaPath?: string\n parentSchema?: boolean\n}\n\nexport function reportError(\n cxt: KeywordErrorCxt,\n error: KeywordErrorDefinition = keywordError,\n errorPaths?: ErrorPaths,\n overrideAllErrors?: boolean\n): void {\n const {it} = cxt\n const {gen, compositeRule, allErrors} = it\n const errObj = errorObjectCode(cxt, error, errorPaths)\n if (overrideAllErrors ?? (compositeRule || allErrors)) {\n addError(gen, errObj)\n } else {\n returnErrors(it, _`[${errObj}]`)\n }\n}\n\nexport function reportExtraError(\n cxt: KeywordErrorCxt,\n error: KeywordErrorDefinition = keywordError,\n errorPaths?: ErrorPaths\n): void {\n const {it} = cxt\n const {gen, compositeRule, allErrors} = it\n const errObj = errorObjectCode(cxt, error, errorPaths)\n addError(gen, errObj)\n if (!(compositeRule || allErrors)) {\n returnErrors(it, N.vErrors)\n }\n}\n\nexport function resetErrorsCount(gen: CodeGen, errsCount: Name): void {\n gen.assign(N.errors, errsCount)\n gen.if(_`${N.vErrors} !== null`, () =>\n gen.if(\n errsCount,\n () => gen.assign(_`${N.vErrors}.length`, errsCount),\n () => gen.assign(N.vErrors, null)\n )\n )\n}\n\nexport function extendErrors({\n gen,\n keyword,\n schemaValue,\n data,\n errsCount,\n it,\n}: KeywordErrorCxt): void {\n /* istanbul ignore if */\n if (errsCount === undefined) throw new Error(\"ajv implementation error\")\n const err = gen.name(\"err\")\n gen.forRange(\"i\", errsCount, N.errors, (i) => {\n gen.const(err, _`${N.vErrors}[${i}]`)\n gen.if(_`${err}.instancePath === undefined`, () =>\n gen.assign(_`${err}.instancePath`, strConcat(N.instancePath, it.errorPath))\n )\n gen.assign(_`${err}.schemaPath`, str`${it.errSchemaPath}/${keyword}`)\n if (it.opts.verbose) {\n gen.assign(_`${err}.schema`, schemaValue)\n gen.assign(_`${err}.data`, data)\n }\n })\n}\n\nfunction addError(gen: CodeGen, errObj: Code): void {\n const err = gen.const(\"err\", errObj)\n gen.if(\n _`${N.vErrors} === null`,\n () => gen.assign(N.vErrors, _`[${err}]`),\n _`${N.vErrors}.push(${err})`\n )\n gen.code(_`${N.errors}++`)\n}\n\nfunction returnErrors(it: SchemaCxt, errs: Code): void {\n const {gen, validateName, schemaEnv} = it\n if (schemaEnv.$async) {\n gen.throw(_`new ${it.ValidationError as Name}(${errs})`)\n } else {\n gen.assign(_`${validateName}.errors`, errs)\n gen.return(false)\n }\n}\n\nconst E = {\n keyword: new Name(\"keyword\"),\n schemaPath: new Name(\"schemaPath\"), // also used in JTD errors\n params: new Name(\"params\"),\n propertyName: new Name(\"propertyName\"),\n message: new Name(\"message\"),\n schema: new Name(\"schema\"),\n parentSchema: new Name(\"parentSchema\"),\n}\n\nfunction errorObjectCode(\n cxt: KeywordErrorCxt,\n error: KeywordErrorDefinition,\n errorPaths?: ErrorPaths\n): Code {\n const {createErrors} = cxt.it\n if (createErrors === false) return _`{}`\n return errorObject(cxt, error, errorPaths)\n}\n\nfunction errorObject(\n cxt: KeywordErrorCxt,\n error: KeywordErrorDefinition,\n errorPaths: ErrorPaths = {}\n): Code {\n const {gen, it} = cxt\n const keyValues: [Name, SafeExpr | string][] = [\n errorInstancePath(it, errorPaths),\n errorSchemaPath(cxt, errorPaths),\n ]\n extraErrorProps(cxt, error, keyValues)\n return gen.object(...keyValues)\n}\n\nfunction errorInstancePath({errorPath}: SchemaCxt, {instancePath}: ErrorPaths): [Name, Code] {\n const instPath = instancePath\n ? str`${errorPath}${getErrorPath(instancePath, Type.Str)}`\n : errorPath\n return [N.instancePath, strConcat(N.instancePath, instPath)]\n}\n\nfunction errorSchemaPath(\n {keyword, it: {errSchemaPath}}: KeywordErrorCxt,\n {schemaPath, parentSchema}: ErrorPaths\n): [Name, string | Code] {\n let schPath = parentSchema ? errSchemaPath : str`${errSchemaPath}/${keyword}`\n if (schemaPath) {\n schPath = str`${schPath}${getErrorPath(schemaPath, Type.Str)}`\n }\n return [E.schemaPath, schPath]\n}\n\nfunction extraErrorProps(\n cxt: KeywordErrorCxt,\n {params, message}: KeywordErrorDefinition,\n keyValues: [Name, SafeExpr | string][]\n): void {\n const {keyword, data, schemaValue, it} = cxt\n const {opts, propertyName, topSchemaRef, schemaPath} = it\n keyValues.push(\n [E.keyword, keyword],\n [E.params, typeof params == \"function\" ? params(cxt) : params || _`{}`]\n )\n if (opts.messages) {\n keyValues.push([E.message, typeof message == \"function\" ? message(cxt) : message])\n }\n if (opts.verbose) {\n keyValues.push(\n [E.schema, schemaValue],\n [E.parentSchema, _`${topSchemaRef}${schemaPath}`],\n [N.data, data]\n )\n }\n if (propertyName) keyValues.push([E.propertyName, propertyName])\n}\n", "import type {KeywordErrorDefinition, KeywordErrorCxt} from \"../../types\"\nimport type {SchemaCxt} from \"..\"\nimport {reportError} from \"../errors\"\nimport {_, Name} from \"../codegen\"\nimport N from \"../names\"\n\nconst boolError: KeywordErrorDefinition = {\n message: \"boolean schema is false\",\n}\n\nexport function topBoolOrEmptySchema(it: SchemaCxt): void {\n const {gen, schema, validateName} = it\n if (schema === false) {\n falseSchemaError(it, false)\n } else if (typeof schema == \"object\" && schema.$async === true) {\n gen.return(N.data)\n } else {\n gen.assign(_`${validateName}.errors`, null)\n gen.return(true)\n }\n}\n\nexport function boolOrEmptySchema(it: SchemaCxt, valid: Name): void {\n const {gen, schema} = it\n if (schema === false) {\n gen.var(valid, false) // TODO var\n falseSchemaError(it)\n } else {\n gen.var(valid, true) // TODO var\n }\n}\n\nfunction falseSchemaError(it: SchemaCxt, overrideAllErrors?: boolean): void {\n const {gen, data} = it\n // TODO maybe some other interface should be used for non-keyword validation errors...\n const cxt: KeywordErrorCxt = {\n gen,\n keyword: \"false schema\",\n data,\n schema: false,\n schemaCode: false,\n schemaValue: false,\n params: {},\n it,\n }\n reportError(cxt, boolError, undefined, overrideAllErrors)\n}\n", "import type {AddedKeywordDefinition} from \"../types\"\n\nconst _jsonTypes = [\"string\", \"number\", \"integer\", \"boolean\", \"null\", \"object\", \"array\"] as const\n\nexport type JSONType = (typeof _jsonTypes)[number]\n\nconst jsonTypes: Set = new Set(_jsonTypes)\n\nexport function isJSONType(x: unknown): x is JSONType {\n return typeof x == \"string\" && jsonTypes.has(x)\n}\n\ntype ValidationTypes = {\n [K in JSONType]: boolean | RuleGroup | undefined\n}\n\nexport interface ValidationRules {\n rules: RuleGroup[]\n post: RuleGroup\n all: {[Key in string]?: boolean | Rule} // rules that have to be validated\n keywords: {[Key in string]?: boolean} // all known keywords (superset of \"all\")\n types: ValidationTypes\n}\n\nexport interface RuleGroup {\n type?: JSONType\n rules: Rule[]\n}\n\n// This interface wraps KeywordDefinition because definition can have multiple keywords\nexport interface Rule {\n keyword: string\n definition: AddedKeywordDefinition\n}\n\nexport function getRules(): ValidationRules {\n const groups: Record<\"number\" | \"string\" | \"array\" | \"object\", RuleGroup> = {\n number: {type: \"number\", rules: []},\n string: {type: \"string\", rules: []},\n array: {type: \"array\", rules: []},\n object: {type: \"object\", rules: []},\n }\n return {\n types: {...groups, integer: true, boolean: true, null: true},\n rules: [{rules: []}, groups.number, groups.string, groups.array, groups.object],\n post: {rules: []},\n all: {},\n keywords: {},\n }\n}\n", "import type {AnySchemaObject} from \"../../types\"\nimport type {SchemaObjCxt} from \"..\"\nimport type {JSONType, RuleGroup, Rule} from \"../rules\"\n\nexport function schemaHasRulesForType(\n {schema, self}: SchemaObjCxt,\n type: JSONType\n): boolean | undefined {\n const group = self.RULES.types[type]\n return group && group !== true && shouldUseGroup(schema, group)\n}\n\nexport function shouldUseGroup(schema: AnySchemaObject, group: RuleGroup): boolean {\n return group.rules.some((rule) => shouldUseRule(schema, rule))\n}\n\nexport function shouldUseRule(schema: AnySchemaObject, rule: Rule): boolean | undefined {\n return (\n schema[rule.keyword] !== undefined ||\n rule.definition.implements?.some((kwd) => schema[kwd] !== undefined)\n )\n}\n", "import type {\n KeywordErrorDefinition,\n KeywordErrorCxt,\n ErrorObject,\n AnySchemaObject,\n} from \"../../types\"\nimport type {SchemaObjCxt} from \"..\"\nimport {isJSONType, JSONType} from \"../rules\"\nimport {schemaHasRulesForType} from \"./applicability\"\nimport {reportError} from \"../errors\"\nimport {_, nil, and, not, operators, Code, Name} from \"../codegen\"\nimport {toHash, schemaRefOrVal} from \"../util\"\n\nexport enum DataType {\n Correct,\n Wrong,\n}\n\nexport function getSchemaTypes(schema: AnySchemaObject): JSONType[] {\n const types = getJSONTypes(schema.type)\n const hasNull = types.includes(\"null\")\n if (hasNull) {\n if (schema.nullable === false) throw new Error(\"type: null contradicts nullable: false\")\n } else {\n if (!types.length && schema.nullable !== undefined) {\n throw new Error('\"nullable\" cannot be used without \"type\"')\n }\n if (schema.nullable === true) types.push(\"null\")\n }\n return types\n}\n\n// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\nexport function getJSONTypes(ts: unknown | unknown[]): JSONType[] {\n const types: unknown[] = Array.isArray(ts) ? ts : ts ? [ts] : []\n if (types.every(isJSONType)) return types\n throw new Error(\"type must be JSONType or JSONType[]: \" + types.join(\",\"))\n}\n\nexport function coerceAndCheckDataType(it: SchemaObjCxt, types: JSONType[]): boolean {\n const {gen, data, opts} = it\n const coerceTo = coerceToTypes(types, opts.coerceTypes)\n const checkTypes =\n types.length > 0 &&\n !(coerceTo.length === 0 && types.length === 1 && schemaHasRulesForType(it, types[0]))\n if (checkTypes) {\n const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong)\n gen.if(wrongType, () => {\n if (coerceTo.length) coerceData(it, types, coerceTo)\n else reportTypeError(it)\n })\n }\n return checkTypes\n}\n\nconst COERCIBLE: Set = new Set([\"string\", \"number\", \"integer\", \"boolean\", \"null\"])\nfunction coerceToTypes(types: JSONType[], coerceTypes?: boolean | \"array\"): JSONType[] {\n return coerceTypes\n ? types.filter((t) => COERCIBLE.has(t) || (coerceTypes === \"array\" && t === \"array\"))\n : []\n}\n\nfunction coerceData(it: SchemaObjCxt, types: JSONType[], coerceTo: JSONType[]): void {\n const {gen, data, opts} = it\n const dataType = gen.let(\"dataType\", _`typeof ${data}`)\n const coerced = gen.let(\"coerced\", _`undefined`)\n if (opts.coerceTypes === \"array\") {\n gen.if(_`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () =>\n gen\n .assign(data, _`${data}[0]`)\n .assign(dataType, _`typeof ${data}`)\n .if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data))\n )\n }\n gen.if(_`${coerced} !== undefined`)\n for (const t of coerceTo) {\n if (COERCIBLE.has(t) || (t === \"array\" && opts.coerceTypes === \"array\")) {\n coerceSpecificType(t)\n }\n }\n gen.else()\n reportTypeError(it)\n gen.endIf()\n\n gen.if(_`${coerced} !== undefined`, () => {\n gen.assign(data, coerced)\n assignParentData(it, coerced)\n })\n\n function coerceSpecificType(t: string): void {\n switch (t) {\n case \"string\":\n gen\n .elseIf(_`${dataType} == \"number\" || ${dataType} == \"boolean\"`)\n .assign(coerced, _`\"\" + ${data}`)\n .elseIf(_`${data} === null`)\n .assign(coerced, _`\"\"`)\n return\n case \"number\":\n gen\n .elseIf(\n _`${dataType} == \"boolean\" || ${data} === null\n || (${dataType} == \"string\" && ${data} && ${data} == +${data})`\n )\n .assign(coerced, _`+${data}`)\n return\n case \"integer\":\n gen\n .elseIf(\n _`${dataType} === \"boolean\" || ${data} === null\n || (${dataType} === \"string\" && ${data} && ${data} == +${data} && !(${data} % 1))`\n )\n .assign(coerced, _`+${data}`)\n return\n case \"boolean\":\n gen\n .elseIf(_`${data} === \"false\" || ${data} === 0 || ${data} === null`)\n .assign(coerced, false)\n .elseIf(_`${data} === \"true\" || ${data} === 1`)\n .assign(coerced, true)\n return\n case \"null\":\n gen.elseIf(_`${data} === \"\" || ${data} === 0 || ${data} === false`)\n gen.assign(coerced, null)\n return\n\n case \"array\":\n gen\n .elseIf(\n _`${dataType} === \"string\" || ${dataType} === \"number\"\n || ${dataType} === \"boolean\" || ${data} === null`\n )\n .assign(coerced, _`[${data}]`)\n }\n }\n}\n\nfunction assignParentData({gen, parentData, parentDataProperty}: SchemaObjCxt, expr: Name): void {\n // TODO use gen.property\n gen.if(_`${parentData} !== undefined`, () =>\n gen.assign(_`${parentData}[${parentDataProperty}]`, expr)\n )\n}\n\nexport function checkDataType(\n dataType: JSONType,\n data: Name,\n strictNums?: boolean | \"log\",\n correct = DataType.Correct\n): Code {\n const EQ = correct === DataType.Correct ? operators.EQ : operators.NEQ\n let cond: Code\n switch (dataType) {\n case \"null\":\n return _`${data} ${EQ} null`\n case \"array\":\n cond = _`Array.isArray(${data})`\n break\n case \"object\":\n cond = _`${data} && typeof ${data} == \"object\" && !Array.isArray(${data})`\n break\n case \"integer\":\n cond = numCond(_`!(${data} % 1) && !isNaN(${data})`)\n break\n case \"number\":\n cond = numCond()\n break\n default:\n return _`typeof ${data} ${EQ} ${dataType}`\n }\n return correct === DataType.Correct ? cond : not(cond)\n\n function numCond(_cond: Code = nil): Code {\n return and(_`typeof ${data} == \"number\"`, _cond, strictNums ? _`isFinite(${data})` : nil)\n }\n}\n\nexport function checkDataTypes(\n dataTypes: JSONType[],\n data: Name,\n strictNums?: boolean | \"log\",\n correct?: DataType\n): Code {\n if (dataTypes.length === 1) {\n return checkDataType(dataTypes[0], data, strictNums, correct)\n }\n let cond: Code\n const types = toHash(dataTypes)\n if (types.array && types.object) {\n const notObj = _`typeof ${data} != \"object\"`\n cond = types.null ? notObj : _`!${data} || ${notObj}`\n delete types.null\n delete types.array\n delete types.object\n } else {\n cond = nil\n }\n if (types.number) delete types.integer\n for (const t in types) cond = and(cond, checkDataType(t as JSONType, data, strictNums, correct))\n return cond\n}\n\nexport type TypeError = ErrorObject<\"type\", {type: string}>\n\nconst typeError: KeywordErrorDefinition = {\n message: ({schema}) => `must be ${schema}`,\n params: ({schema, schemaValue}) =>\n typeof schema == \"string\" ? _`{type: ${schema}}` : _`{type: ${schemaValue}}`,\n}\n\nexport function reportTypeError(it: SchemaObjCxt): void {\n const cxt = getTypeErrorContext(it)\n reportError(cxt, typeError)\n}\n\nfunction getTypeErrorContext(it: SchemaObjCxt): KeywordErrorCxt {\n const {gen, data, schema} = it\n const schemaCode = schemaRefOrVal(it, schema, \"type\")\n return {\n gen,\n keyword: \"type\",\n data,\n schema: schema.type,\n schemaCode,\n schemaValue: schemaCode,\n parentSchema: schema,\n params: {},\n it,\n }\n}\n", "import type {SchemaObjCxt} from \"..\"\nimport {_, getProperty, stringify} from \"../codegen\"\nimport {checkStrictMode} from \"../util\"\n\nexport function assignDefaults(it: SchemaObjCxt, ty?: string): void {\n const {properties, items} = it.schema\n if (ty === \"object\" && properties) {\n for (const key in properties) {\n assignDefault(it, key, properties[key].default)\n }\n } else if (ty === \"array\" && Array.isArray(items)) {\n items.forEach((sch, i: number) => assignDefault(it, i, sch.default))\n }\n}\n\nfunction assignDefault(it: SchemaObjCxt, prop: string | number, defaultValue: unknown): void {\n const {gen, compositeRule, data, opts} = it\n if (defaultValue === undefined) return\n const childData = _`${data}${getProperty(prop)}`\n if (compositeRule) {\n checkStrictMode(it, `default is ignored for: ${childData}`)\n return\n }\n\n let condition = _`${childData} === undefined`\n if (opts.useDefaults === \"empty\") {\n condition = _`${condition} || ${childData} === null || ${childData} === \"\"`\n }\n // `${childData} === undefined` +\n // (opts.useDefaults === \"empty\" ? ` || ${childData} === null || ${childData} === \"\"` : \"\")\n gen.if(condition, _`${childData} = ${stringify(defaultValue)}`)\n}\n", "import type {AnySchema, SchemaMap} from \"../types\"\nimport type {SchemaCxt} from \"../compile\"\nimport type {KeywordCxt} from \"../compile/validate\"\nimport {CodeGen, _, and, or, not, nil, strConcat, getProperty, Code, Name} from \"../compile/codegen\"\nimport {alwaysValidSchema, Type} from \"../compile/util\"\nimport N from \"../compile/names\"\nimport {useFunc} from \"../compile/util\"\nexport function checkReportMissingProp(cxt: KeywordCxt, prop: string): void {\n const {gen, data, it} = cxt\n gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {\n cxt.setParams({missingProperty: _`${prop}`}, true)\n cxt.error()\n })\n}\n\nexport function checkMissingProp(\n {gen, data, it: {opts}}: KeywordCxt,\n properties: string[],\n missing: Name\n): Code {\n return or(\n ...properties.map((prop) =>\n and(noPropertyInData(gen, data, prop, opts.ownProperties), _`${missing} = ${prop}`)\n )\n )\n}\n\nexport function reportMissingProp(cxt: KeywordCxt, missing: Name): void {\n cxt.setParams({missingProperty: missing}, true)\n cxt.error()\n}\n\nexport function hasPropFunc(gen: CodeGen): Name {\n return gen.scopeValue(\"func\", {\n // eslint-disable-next-line @typescript-eslint/unbound-method\n ref: Object.prototype.hasOwnProperty,\n code: _`Object.prototype.hasOwnProperty`,\n })\n}\n\nexport function isOwnProperty(gen: CodeGen, data: Name, property: Name | string): Code {\n return _`${hasPropFunc(gen)}.call(${data}, ${property})`\n}\n\nexport function propertyInData(\n gen: CodeGen,\n data: Name,\n property: Name | string,\n ownProperties?: boolean\n): Code {\n const cond = _`${data}${getProperty(property)} !== undefined`\n return ownProperties ? _`${cond} && ${isOwnProperty(gen, data, property)}` : cond\n}\n\nexport function noPropertyInData(\n gen: CodeGen,\n data: Name,\n property: Name | string,\n ownProperties?: boolean\n): Code {\n const cond = _`${data}${getProperty(property)} === undefined`\n return ownProperties ? or(cond, not(isOwnProperty(gen, data, property))) : cond\n}\n\nexport function allSchemaProperties(schemaMap?: SchemaMap): string[] {\n return schemaMap ? Object.keys(schemaMap).filter((p) => p !== \"__proto__\") : []\n}\n\nexport function schemaProperties(it: SchemaCxt, schemaMap: SchemaMap): string[] {\n return allSchemaProperties(schemaMap).filter(\n (p) => !alwaysValidSchema(it, schemaMap[p] as AnySchema)\n )\n}\n\nexport function callValidateCode(\n {schemaCode, data, it: {gen, topSchemaRef, schemaPath, errorPath}, it}: KeywordCxt,\n func: Code,\n context: Code,\n passSchema?: boolean\n): Code {\n const dataAndSchema = passSchema ? _`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data\n const valCxt: [Name, Code | number][] = [\n [N.instancePath, strConcat(N.instancePath, errorPath)],\n [N.parentData, it.parentData],\n [N.parentDataProperty, it.parentDataProperty],\n [N.rootData, N.rootData],\n ]\n if (it.opts.dynamicRef) valCxt.push([N.dynamicAnchors, N.dynamicAnchors])\n const args = _`${dataAndSchema}, ${gen.object(...valCxt)}`\n return context !== nil ? _`${func}.call(${context}, ${args})` : _`${func}(${args})`\n}\n\nconst newRegExp = _`new RegExp`\n\nexport function usePattern({gen, it: {opts}}: KeywordCxt, pattern: string): Name {\n const u = opts.unicodeRegExp ? \"u\" : \"\"\n const {regExp} = opts.code\n const rx = regExp(pattern, u)\n\n return gen.scopeValue(\"pattern\", {\n key: rx.toString(),\n ref: rx,\n code: _`${regExp.code === \"new RegExp\" ? newRegExp : useFunc(gen, regExp)}(${pattern}, ${u})`,\n })\n}\n\nexport function validateArray(cxt: KeywordCxt): Name {\n const {gen, data, keyword, it} = cxt\n const valid = gen.name(\"valid\")\n if (it.allErrors) {\n const validArr = gen.let(\"valid\", true)\n validateItems(() => gen.assign(validArr, false))\n return validArr\n }\n gen.var(valid, true)\n validateItems(() => gen.break())\n return valid\n\n function validateItems(notValid: () => void): void {\n const len = gen.const(\"len\", _`${data}.length`)\n gen.forRange(\"i\", 0, len, (i) => {\n cxt.subschema(\n {\n keyword,\n dataProp: i,\n dataPropType: Type.Num,\n },\n valid\n )\n gen.if(not(valid), notValid)\n })\n }\n}\n\nexport function validateUnion(cxt: KeywordCxt): void {\n const {gen, schema, keyword, it} = cxt\n /* istanbul ignore if */\n if (!Array.isArray(schema)) throw new Error(\"ajv implementation error\")\n const alwaysValid = schema.some((sch: AnySchema) => alwaysValidSchema(it, sch))\n if (alwaysValid && !it.opts.unevaluated) return\n\n const valid = gen.let(\"valid\", false)\n const schValid = gen.name(\"_valid\")\n\n gen.block(() =>\n schema.forEach((_sch: AnySchema, i: number) => {\n const schCxt = cxt.subschema(\n {\n keyword,\n schemaProp: i,\n compositeRule: true,\n },\n schValid\n )\n gen.assign(valid, _`${valid} || ${schValid}`)\n const merged = cxt.mergeValidEvaluated(schCxt, schValid)\n // can short-circuit if `unevaluatedProperties/Items` not supported (opts.unevaluated !== true)\n // or if all properties and items were evaluated (it.props === true && it.items === true)\n if (!merged) gen.if(not(valid))\n })\n )\n\n cxt.result(\n valid,\n () => cxt.reset(),\n () => cxt.error(true)\n )\n}\n", "import type {KeywordCxt} from \".\"\nimport type {\n AnySchema,\n SchemaValidateFunction,\n AnyValidateFunction,\n AddedKeywordDefinition,\n MacroKeywordDefinition,\n FuncKeywordDefinition,\n} from \"../../types\"\nimport type {SchemaObjCxt} from \"..\"\nimport {_, nil, not, stringify, Code, Name, CodeGen} from \"../codegen\"\nimport N from \"../names\"\nimport type {JSONType} from \"../rules\"\nimport {callValidateCode} from \"../../vocabularies/code\"\nimport {extendErrors} from \"../errors\"\n\ntype KeywordCompilationResult = AnySchema | SchemaValidateFunction | AnyValidateFunction\n\nexport function macroKeywordCode(cxt: KeywordCxt, def: MacroKeywordDefinition): void {\n const {gen, keyword, schema, parentSchema, it} = cxt\n const macroSchema = def.macro.call(it.self, schema, parentSchema, it)\n const schemaRef = useKeyword(gen, keyword, macroSchema)\n if (it.opts.validateSchema !== false) it.self.validateSchema(macroSchema, true)\n\n const valid = gen.name(\"valid\")\n cxt.subschema(\n {\n schema: macroSchema,\n schemaPath: nil,\n errSchemaPath: `${it.errSchemaPath}/${keyword}`,\n topSchemaRef: schemaRef,\n compositeRule: true,\n },\n valid\n )\n cxt.pass(valid, () => cxt.error(true))\n}\n\nexport function funcKeywordCode(cxt: KeywordCxt, def: FuncKeywordDefinition): void {\n const {gen, keyword, schema, parentSchema, $data, it} = cxt\n checkAsyncKeyword(it, def)\n const validate =\n !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate\n const validateRef = useKeyword(gen, keyword, validate)\n const valid = gen.let(\"valid\")\n cxt.block$data(valid, validateKeyword)\n cxt.ok(def.valid ?? valid)\n\n function validateKeyword(): void {\n if (def.errors === false) {\n assignValid()\n if (def.modifying) modifyData(cxt)\n reportErrs(() => cxt.error())\n } else {\n const ruleErrs = def.async ? validateAsync() : validateSync()\n if (def.modifying) modifyData(cxt)\n reportErrs(() => addErrs(cxt, ruleErrs))\n }\n }\n\n function validateAsync(): Name {\n const ruleErrs = gen.let(\"ruleErrs\", null)\n gen.try(\n () => assignValid(_`await `),\n (e) =>\n gen.assign(valid, false).if(\n _`${e} instanceof ${it.ValidationError as Name}`,\n () => gen.assign(ruleErrs, _`${e}.errors`),\n () => gen.throw(e)\n )\n )\n return ruleErrs\n }\n\n function validateSync(): Code {\n const validateErrs = _`${validateRef}.errors`\n gen.assign(validateErrs, null)\n assignValid(nil)\n return validateErrs\n }\n\n function assignValid(_await: Code = def.async ? _`await ` : nil): void {\n const passCxt = it.opts.passContext ? N.this : N.self\n const passSchema = !((\"compile\" in def && !$data) || def.schema === false)\n gen.assign(\n valid,\n _`${_await}${callValidateCode(cxt, validateRef, passCxt, passSchema)}`,\n def.modifying\n )\n }\n\n function reportErrs(errors: () => void): void {\n gen.if(not(def.valid ?? valid), errors)\n }\n}\n\nfunction modifyData(cxt: KeywordCxt): void {\n const {gen, data, it} = cxt\n gen.if(it.parentData, () => gen.assign(data, _`${it.parentData}[${it.parentDataProperty}]`))\n}\n\nfunction addErrs(cxt: KeywordCxt, errs: Code): void {\n const {gen} = cxt\n gen.if(\n _`Array.isArray(${errs})`,\n () => {\n gen\n .assign(N.vErrors, _`${N.vErrors} === null ? ${errs} : ${N.vErrors}.concat(${errs})`)\n .assign(N.errors, _`${N.vErrors}.length`)\n extendErrors(cxt)\n },\n () => cxt.error()\n )\n}\n\nfunction checkAsyncKeyword({schemaEnv}: SchemaObjCxt, def: FuncKeywordDefinition): void {\n if (def.async && !schemaEnv.$async) throw new Error(\"async keyword in sync schema\")\n}\n\nfunction useKeyword(gen: CodeGen, keyword: string, result?: KeywordCompilationResult): Name {\n if (result === undefined) throw new Error(`keyword \"${keyword}\" failed to compile`)\n return gen.scopeValue(\n \"keyword\",\n typeof result == \"function\" ? {ref: result} : {ref: result, code: stringify(result)}\n )\n}\n\nexport function validSchemaType(\n schema: unknown,\n schemaType: JSONType[],\n allowUndefined = false\n): boolean {\n // TODO add tests\n return (\n !schemaType.length ||\n schemaType.some((st) =>\n st === \"array\"\n ? Array.isArray(schema)\n : st === \"object\"\n ? schema && typeof schema == \"object\" && !Array.isArray(schema)\n : typeof schema == st || (allowUndefined && typeof schema == \"undefined\")\n )\n )\n}\n\nexport function validateKeywordUsage(\n {schema, opts, self, errSchemaPath}: SchemaObjCxt,\n def: AddedKeywordDefinition,\n keyword: string\n): void {\n /* istanbul ignore if */\n if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {\n throw new Error(\"ajv implementation error\")\n }\n\n const deps = def.dependencies\n if (deps?.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {\n throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(\",\")}`)\n }\n\n if (def.validateSchema) {\n const valid = def.validateSchema(schema[keyword])\n if (!valid) {\n const msg =\n `keyword \"${keyword}\" value is invalid at path \"${errSchemaPath}\": ` +\n self.errorsText(def.validateSchema.errors)\n if (opts.validateSchema === \"log\") self.logger.error(msg)\n else throw new Error(msg)\n }\n }\n}\n", "import type {AnySchema} from \"../../types\"\nimport type {SchemaObjCxt} from \"..\"\nimport {_, str, getProperty, Code, Name} from \"../codegen\"\nimport {escapeFragment, getErrorPath, Type} from \"../util\"\nimport type {JSONType} from \"../rules\"\n\nexport interface SubschemaContext {\n // TODO use Optional? align with SchemCxt property types\n schema: AnySchema\n schemaPath: Code\n errSchemaPath: string\n topSchemaRef?: Code\n errorPath?: Code\n dataLevel?: number\n dataTypes?: JSONType[]\n data?: Name\n parentData?: Name\n parentDataProperty?: Code | number\n dataNames?: Name[]\n dataPathArr?: (Code | number)[]\n propertyName?: Name\n jtdDiscriminator?: string\n jtdMetadata?: boolean\n compositeRule?: true\n createErrors?: boolean\n allErrors?: boolean\n}\n\nexport type SubschemaArgs = Partial<{\n keyword: string\n schemaProp: string | number\n schema: AnySchema\n schemaPath: Code\n errSchemaPath: string\n topSchemaRef: Code\n data: Name | Code\n dataProp: Code | string | number\n dataTypes: JSONType[]\n definedProperties: Set\n propertyName: Name\n dataPropType: Type\n jtdDiscriminator: string\n jtdMetadata: boolean\n compositeRule: true\n createErrors: boolean\n allErrors: boolean\n}>\n\nexport function getSubschema(\n it: SchemaObjCxt,\n {keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef}: SubschemaArgs\n): SubschemaContext {\n if (keyword !== undefined && schema !== undefined) {\n throw new Error('both \"keyword\" and \"schema\" passed, only one allowed')\n }\n\n if (keyword !== undefined) {\n const sch = it.schema[keyword]\n return schemaProp === undefined\n ? {\n schema: sch,\n schemaPath: _`${it.schemaPath}${getProperty(keyword)}`,\n errSchemaPath: `${it.errSchemaPath}/${keyword}`,\n }\n : {\n schema: sch[schemaProp],\n schemaPath: _`${it.schemaPath}${getProperty(keyword)}${getProperty(schemaProp)}`,\n errSchemaPath: `${it.errSchemaPath}/${keyword}/${escapeFragment(schemaProp)}`,\n }\n }\n\n if (schema !== undefined) {\n if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {\n throw new Error('\"schemaPath\", \"errSchemaPath\" and \"topSchemaRef\" are required with \"schema\"')\n }\n return {\n schema,\n schemaPath,\n topSchemaRef,\n errSchemaPath,\n }\n }\n\n throw new Error('either \"keyword\" or \"schema\" must be passed')\n}\n\nexport function extendSubschemaData(\n subschema: SubschemaContext,\n it: SchemaObjCxt,\n {dataProp, dataPropType: dpType, data, dataTypes, propertyName}: SubschemaArgs\n): void {\n if (data !== undefined && dataProp !== undefined) {\n throw new Error('both \"data\" and \"dataProp\" passed, only one allowed')\n }\n\n const {gen} = it\n\n if (dataProp !== undefined) {\n const {errorPath, dataPathArr, opts} = it\n const nextData = gen.let(\"data\", _`${it.data}${getProperty(dataProp)}`, true)\n dataContextProps(nextData)\n subschema.errorPath = str`${errorPath}${getErrorPath(dataProp, dpType, opts.jsPropertySyntax)}`\n subschema.parentDataProperty = _`${dataProp}`\n subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty]\n }\n\n if (data !== undefined) {\n const nextData = data instanceof Name ? data : gen.let(\"data\", data, true) // replaceable if used once?\n dataContextProps(nextData)\n if (propertyName !== undefined) subschema.propertyName = propertyName\n // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr\n }\n\n if (dataTypes) subschema.dataTypes = dataTypes\n\n function dataContextProps(_nextData: Name): void {\n subschema.data = _nextData\n subschema.dataLevel = it.dataLevel + 1\n subschema.dataTypes = []\n it.definedProperties = new Set()\n subschema.parentData = it.data\n subschema.dataNames = [...it.dataNames, _nextData]\n }\n}\n\nexport function extendSubschemaMode(\n subschema: SubschemaContext,\n {jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors}: SubschemaArgs\n): void {\n if (compositeRule !== undefined) subschema.compositeRule = compositeRule\n if (createErrors !== undefined) subschema.createErrors = createErrors\n if (allErrors !== undefined) subschema.allErrors = allErrors\n subschema.jtdDiscriminator = jtdDiscriminator // not inherited\n subschema.jtdMetadata = jtdMetadata // not inherited\n}\n", "'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n if (a === b) return true;\n\n if (a && b && typeof a == 'object' && typeof b == 'object') {\n if (a.constructor !== b.constructor) return false;\n\n var length, i, keys;\n if (Array.isArray(a)) {\n length = a.length;\n if (length != b.length) return false;\n for (i = length; i-- !== 0;)\n if (!equal(a[i], b[i])) return false;\n return true;\n }\n\n\n\n if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n keys = Object.keys(a);\n length = keys.length;\n if (length !== Object.keys(b).length) return false;\n\n for (i = length; i-- !== 0;)\n if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n for (i = length; i-- !== 0;) {\n var key = keys[i];\n\n if (!equal(a[key], b[key])) return false;\n }\n\n return true;\n }\n\n // true if both NaN, false otherwise\n return a!==a && b!==b;\n};\n", "'use strict';\n\nvar traverse = module.exports = function (schema, opts, cb) {\n // Legacy support for v0.3.1 and earlier.\n if (typeof opts == 'function') {\n cb = opts;\n opts = {};\n }\n\n cb = opts.cb || cb;\n var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};\n var post = cb.post || function() {};\n\n _traverse(opts, pre, post, schema, '', schema);\n};\n\n\ntraverse.keywords = {\n additionalItems: true,\n items: true,\n contains: true,\n additionalProperties: true,\n propertyNames: true,\n not: true,\n if: true,\n then: true,\n else: true\n};\n\ntraverse.arrayKeywords = {\n items: true,\n allOf: true,\n anyOf: true,\n oneOf: true\n};\n\ntraverse.propsKeywords = {\n $defs: true,\n definitions: true,\n properties: true,\n patternProperties: true,\n dependencies: true\n};\n\ntraverse.skipKeywords = {\n default: true,\n enum: true,\n const: true,\n required: true,\n maximum: true,\n minimum: true,\n exclusiveMaximum: true,\n exclusiveMinimum: true,\n multipleOf: true,\n maxLength: true,\n minLength: true,\n pattern: true,\n format: true,\n maxItems: true,\n minItems: true,\n uniqueItems: true,\n maxProperties: true,\n minProperties: true\n};\n\n\nfunction _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n if (schema && typeof schema == 'object' && !Array.isArray(schema)) {\n pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n for (var key in schema) {\n var sch = schema[key];\n if (Array.isArray(sch)) {\n if (key in traverse.arrayKeywords) {\n for (var i=0; i (count += countKeys(sch)))\n }\n if (count === Infinity) return Infinity\n }\n return count\n}\n\nexport function getFullPath(resolver: UriResolver, id = \"\", normalize?: boolean): string {\n if (normalize !== false) id = normalizeId(id)\n const p = resolver.parse(id)\n return _getFullPath(resolver, p)\n}\n\nexport function _getFullPath(resolver: UriResolver, p: URIComponent): string {\n const serialized = resolver.serialize(p)\n return serialized.split(\"#\")[0] + \"#\"\n}\n\nconst TRAILING_SLASH_HASH = /#\\/?$/\nexport function normalizeId(id: string | undefined): string {\n return id ? id.replace(TRAILING_SLASH_HASH, \"\") : \"\"\n}\n\nexport function resolveUrl(resolver: UriResolver, baseId: string, id: string): string {\n id = normalizeId(id)\n return resolver.resolve(baseId, id)\n}\n\nconst ANCHOR = /^[a-z_][-a-z0-9._]*$/i\n\nexport function getSchemaRefs(this: Ajv, schema: AnySchema, baseId: string): LocalRefs {\n if (typeof schema == \"boolean\") return {}\n const {schemaId, uriResolver} = this.opts\n const schId = normalizeId(schema[schemaId] || baseId)\n const baseIds: {[JsonPtr in string]?: string} = {\"\": schId}\n const pathPrefix = getFullPath(uriResolver, schId, false)\n const localRefs: LocalRefs = {}\n const schemaRefs: Set = new Set()\n\n traverse(schema, {allKeys: true}, (sch, jsonPtr, _, parentJsonPtr) => {\n if (parentJsonPtr === undefined) return\n const fullPath = pathPrefix + jsonPtr\n let innerBaseId = baseIds[parentJsonPtr]\n if (typeof sch[schemaId] == \"string\") innerBaseId = addRef.call(this, sch[schemaId])\n addAnchor.call(this, sch.$anchor)\n addAnchor.call(this, sch.$dynamicAnchor)\n baseIds[jsonPtr] = innerBaseId\n\n function addRef(this: Ajv, ref: string): string {\n // eslint-disable-next-line @typescript-eslint/unbound-method\n const _resolve = this.opts.uriResolver.resolve\n ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref)\n if (schemaRefs.has(ref)) throw ambiguos(ref)\n schemaRefs.add(ref)\n let schOrRef = this.refs[ref]\n if (typeof schOrRef == \"string\") schOrRef = this.refs[schOrRef]\n if (typeof schOrRef == \"object\") {\n checkAmbiguosRef(sch, schOrRef.schema, ref)\n } else if (ref !== normalizeId(fullPath)) {\n if (ref[0] === \"#\") {\n checkAmbiguosRef(sch, localRefs[ref], ref)\n localRefs[ref] = sch\n } else {\n this.refs[ref] = fullPath\n }\n }\n return ref\n }\n\n function addAnchor(this: Ajv, anchor: unknown): void {\n if (typeof anchor == \"string\") {\n if (!ANCHOR.test(anchor)) throw new Error(`invalid anchor \"${anchor}\"`)\n addRef.call(this, `#${anchor}`)\n }\n }\n })\n\n return localRefs\n\n function checkAmbiguosRef(sch1: AnySchema, sch2: AnySchema | undefined, ref: string): void {\n if (sch2 !== undefined && !equal(sch1, sch2)) throw ambiguos(ref)\n }\n\n function ambiguos(ref: string): Error {\n return new Error(`reference \"${ref}\" resolves to more than one schema`)\n }\n}\n", "import type {\n AddedKeywordDefinition,\n AnySchema,\n AnySchemaObject,\n KeywordErrorCxt,\n KeywordCxtParams,\n} from \"../../types\"\nimport type {SchemaCxt, SchemaObjCxt} from \"..\"\nimport type {InstanceOptions} from \"../../core\"\nimport {boolOrEmptySchema, topBoolOrEmptySchema} from \"./boolSchema\"\nimport {coerceAndCheckDataType, getSchemaTypes} from \"./dataType\"\nimport {shouldUseGroup, shouldUseRule} from \"./applicability\"\nimport {checkDataType, checkDataTypes, reportTypeError, DataType} from \"./dataType\"\nimport {assignDefaults} from \"./defaults\"\nimport {funcKeywordCode, macroKeywordCode, validateKeywordUsage, validSchemaType} from \"./keyword\"\nimport {getSubschema, extendSubschemaData, SubschemaArgs, extendSubschemaMode} from \"./subschema\"\nimport {_, nil, str, or, not, getProperty, Block, Code, Name, CodeGen} from \"../codegen\"\nimport N from \"../names\"\nimport {resolveUrl} from \"../resolve\"\nimport {\n schemaRefOrVal,\n schemaHasRulesButRef,\n checkUnknownRules,\n checkStrictMode,\n unescapeJsonPointer,\n mergeEvaluated,\n} from \"../util\"\nimport type {JSONType, Rule, RuleGroup} from \"../rules\"\nimport {\n ErrorPaths,\n reportError,\n reportExtraError,\n resetErrorsCount,\n keyword$DataError,\n} from \"../errors\"\n\n// schema compilation - generates validation function, subschemaCode (below) is used for subschemas\nexport function validateFunctionCode(it: SchemaCxt): void {\n if (isSchemaObj(it)) {\n checkKeywords(it)\n if (schemaCxtHasRules(it)) {\n topSchemaObjCode(it)\n return\n }\n }\n validateFunction(it, () => topBoolOrEmptySchema(it))\n}\n\nfunction validateFunction(\n {gen, validateName, schema, schemaEnv, opts}: SchemaCxt,\n body: Block\n): void {\n if (opts.code.es5) {\n gen.func(validateName, _`${N.data}, ${N.valCxt}`, schemaEnv.$async, () => {\n gen.code(_`\"use strict\"; ${funcSourceUrl(schema, opts)}`)\n destructureValCxtES5(gen, opts)\n gen.code(body)\n })\n } else {\n gen.func(validateName, _`${N.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () =>\n gen.code(funcSourceUrl(schema, opts)).code(body)\n )\n }\n}\n\nfunction destructureValCxt(opts: InstanceOptions): Code {\n return _`{${N.instancePath}=\"\", ${N.parentData}, ${N.parentDataProperty}, ${N.rootData}=${\n N.data\n }${opts.dynamicRef ? _`, ${N.dynamicAnchors}={}` : nil}}={}`\n}\n\nfunction destructureValCxtES5(gen: CodeGen, opts: InstanceOptions): void {\n gen.if(\n N.valCxt,\n () => {\n gen.var(N.instancePath, _`${N.valCxt}.${N.instancePath}`)\n gen.var(N.parentData, _`${N.valCxt}.${N.parentData}`)\n gen.var(N.parentDataProperty, _`${N.valCxt}.${N.parentDataProperty}`)\n gen.var(N.rootData, _`${N.valCxt}.${N.rootData}`)\n if (opts.dynamicRef) gen.var(N.dynamicAnchors, _`${N.valCxt}.${N.dynamicAnchors}`)\n },\n () => {\n gen.var(N.instancePath, _`\"\"`)\n gen.var(N.parentData, _`undefined`)\n gen.var(N.parentDataProperty, _`undefined`)\n gen.var(N.rootData, N.data)\n if (opts.dynamicRef) gen.var(N.dynamicAnchors, _`{}`)\n }\n )\n}\n\nfunction topSchemaObjCode(it: SchemaObjCxt): void {\n const {schema, opts, gen} = it\n validateFunction(it, () => {\n if (opts.$comment && schema.$comment) commentKeyword(it)\n checkNoDefault(it)\n gen.let(N.vErrors, null)\n gen.let(N.errors, 0)\n if (opts.unevaluated) resetEvaluated(it)\n typeAndKeywords(it)\n returnResults(it)\n })\n return\n}\n\nfunction resetEvaluated(it: SchemaObjCxt): void {\n // TODO maybe some hook to execute it in the end to check whether props/items are Name, as in assignEvaluated\n const {gen, validateName} = it\n it.evaluated = gen.const(\"evaluated\", _`${validateName}.evaluated`)\n gen.if(_`${it.evaluated}.dynamicProps`, () => gen.assign(_`${it.evaluated}.props`, _`undefined`))\n gen.if(_`${it.evaluated}.dynamicItems`, () => gen.assign(_`${it.evaluated}.items`, _`undefined`))\n}\n\nfunction funcSourceUrl(schema: AnySchema, opts: InstanceOptions): Code {\n const schId = typeof schema == \"object\" && schema[opts.schemaId]\n return schId && (opts.code.source || opts.code.process) ? _`/*# sourceURL=${schId} */` : nil\n}\n\n// schema compilation - this function is used recursively to generate code for sub-schemas\nfunction subschemaCode(it: SchemaCxt, valid: Name): void {\n if (isSchemaObj(it)) {\n checkKeywords(it)\n if (schemaCxtHasRules(it)) {\n subSchemaObjCode(it, valid)\n return\n }\n }\n boolOrEmptySchema(it, valid)\n}\n\nfunction schemaCxtHasRules({schema, self}: SchemaCxt): boolean {\n if (typeof schema == \"boolean\") return !schema\n for (const key in schema) if (self.RULES.all[key]) return true\n return false\n}\n\nfunction isSchemaObj(it: SchemaCxt): it is SchemaObjCxt {\n return typeof it.schema != \"boolean\"\n}\n\nfunction subSchemaObjCode(it: SchemaObjCxt, valid: Name): void {\n const {schema, gen, opts} = it\n if (opts.$comment && schema.$comment) commentKeyword(it)\n updateContext(it)\n checkAsyncSchema(it)\n const errsCount = gen.const(\"_errs\", N.errors)\n typeAndKeywords(it, errsCount)\n // TODO var\n gen.var(valid, _`${errsCount} === ${N.errors}`)\n}\n\nfunction checkKeywords(it: SchemaObjCxt): void {\n checkUnknownRules(it)\n checkRefsAndKeywords(it)\n}\n\nfunction typeAndKeywords(it: SchemaObjCxt, errsCount?: Name): void {\n if (it.opts.jtd) return schemaKeywords(it, [], false, errsCount)\n const types = getSchemaTypes(it.schema)\n const checkedTypes = coerceAndCheckDataType(it, types)\n schemaKeywords(it, types, !checkedTypes, errsCount)\n}\n\nfunction checkRefsAndKeywords(it: SchemaObjCxt): void {\n const {schema, errSchemaPath, opts, self} = it\n if (schema.$ref && opts.ignoreKeywordsWithRef && schemaHasRulesButRef(schema, self.RULES)) {\n self.logger.warn(`$ref: keywords ignored in schema at path \"${errSchemaPath}\"`)\n }\n}\n\nfunction checkNoDefault(it: SchemaObjCxt): void {\n const {schema, opts} = it\n if (schema.default !== undefined && opts.useDefaults && opts.strictSchema) {\n checkStrictMode(it, \"default is ignored in the schema root\")\n }\n}\n\nfunction updateContext(it: SchemaObjCxt): void {\n const schId = it.schema[it.opts.schemaId]\n if (schId) it.baseId = resolveUrl(it.opts.uriResolver, it.baseId, schId)\n}\n\nfunction checkAsyncSchema(it: SchemaObjCxt): void {\n if (it.schema.$async && !it.schemaEnv.$async) throw new Error(\"async schema in sync schema\")\n}\n\nfunction commentKeyword({gen, schemaEnv, schema, errSchemaPath, opts}: SchemaObjCxt): void {\n const msg = schema.$comment\n if (opts.$comment === true) {\n gen.code(_`${N.self}.logger.log(${msg})`)\n } else if (typeof opts.$comment == \"function\") {\n const schemaPath = str`${errSchemaPath}/$comment`\n const rootName = gen.scopeValue(\"root\", {ref: schemaEnv.root})\n gen.code(_`${N.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`)\n }\n}\n\nfunction returnResults(it: SchemaCxt): void {\n const {gen, schemaEnv, validateName, ValidationError, opts} = it\n if (schemaEnv.$async) {\n // TODO assign unevaluated\n gen.if(\n _`${N.errors} === 0`,\n () => gen.return(N.data),\n () => gen.throw(_`new ${ValidationError as Name}(${N.vErrors})`)\n )\n } else {\n gen.assign(_`${validateName}.errors`, N.vErrors)\n if (opts.unevaluated) assignEvaluated(it)\n gen.return(_`${N.errors} === 0`)\n }\n}\n\nfunction assignEvaluated({gen, evaluated, props, items}: SchemaCxt): void {\n if (props instanceof Name) gen.assign(_`${evaluated}.props`, props)\n if (items instanceof Name) gen.assign(_`${evaluated}.items`, items)\n}\n\nfunction schemaKeywords(\n it: SchemaObjCxt,\n types: JSONType[],\n typeErrors: boolean,\n errsCount?: Name\n): void {\n const {gen, schema, data, allErrors, opts, self} = it\n const {RULES} = self\n if (schema.$ref && (opts.ignoreKeywordsWithRef || !schemaHasRulesButRef(schema, RULES))) {\n gen.block(() => keywordCode(it, \"$ref\", (RULES.all.$ref as Rule).definition)) // TODO typecast\n return\n }\n if (!opts.jtd) checkStrictTypes(it, types)\n gen.block(() => {\n for (const group of RULES.rules) groupKeywords(group)\n groupKeywords(RULES.post)\n })\n\n function groupKeywords(group: RuleGroup): void {\n if (!shouldUseGroup(schema, group)) return\n if (group.type) {\n gen.if(checkDataType(group.type, data, opts.strictNumbers))\n iterateKeywords(it, group)\n if (types.length === 1 && types[0] === group.type && typeErrors) {\n gen.else()\n reportTypeError(it)\n }\n gen.endIf()\n } else {\n iterateKeywords(it, group)\n }\n // TODO make it \"ok\" call?\n if (!allErrors) gen.if(_`${N.errors} === ${errsCount || 0}`)\n }\n}\n\nfunction iterateKeywords(it: SchemaObjCxt, group: RuleGroup): void {\n const {\n gen,\n schema,\n opts: {useDefaults},\n } = it\n if (useDefaults) assignDefaults(it, group.type)\n gen.block(() => {\n for (const rule of group.rules) {\n if (shouldUseRule(schema, rule)) {\n keywordCode(it, rule.keyword, rule.definition, group.type)\n }\n }\n })\n}\n\nfunction checkStrictTypes(it: SchemaObjCxt, types: JSONType[]): void {\n if (it.schemaEnv.meta || !it.opts.strictTypes) return\n checkContextTypes(it, types)\n if (!it.opts.allowUnionTypes) checkMultipleTypes(it, types)\n checkKeywordTypes(it, it.dataTypes)\n}\n\nfunction checkContextTypes(it: SchemaObjCxt, types: JSONType[]): void {\n if (!types.length) return\n if (!it.dataTypes.length) {\n it.dataTypes = types\n return\n }\n types.forEach((t) => {\n if (!includesType(it.dataTypes, t)) {\n strictTypesError(it, `type \"${t}\" not allowed by context \"${it.dataTypes.join(\",\")}\"`)\n }\n })\n narrowSchemaTypes(it, types)\n}\n\nfunction checkMultipleTypes(it: SchemaObjCxt, ts: JSONType[]): void {\n if (ts.length > 1 && !(ts.length === 2 && ts.includes(\"null\"))) {\n strictTypesError(it, \"use allowUnionTypes to allow union type keyword\")\n }\n}\n\nfunction checkKeywordTypes(it: SchemaObjCxt, ts: JSONType[]): void {\n const rules = it.self.RULES.all\n for (const keyword in rules) {\n const rule = rules[keyword]\n if (typeof rule == \"object\" && shouldUseRule(it.schema, rule)) {\n const {type} = rule.definition\n if (type.length && !type.some((t) => hasApplicableType(ts, t))) {\n strictTypesError(it, `missing type \"${type.join(\",\")}\" for keyword \"${keyword}\"`)\n }\n }\n }\n}\n\nfunction hasApplicableType(schTs: JSONType[], kwdT: JSONType): boolean {\n return schTs.includes(kwdT) || (kwdT === \"number\" && schTs.includes(\"integer\"))\n}\n\nfunction includesType(ts: JSONType[], t: JSONType): boolean {\n return ts.includes(t) || (t === \"integer\" && ts.includes(\"number\"))\n}\n\nfunction narrowSchemaTypes(it: SchemaObjCxt, withTypes: JSONType[]): void {\n const ts: JSONType[] = []\n for (const t of it.dataTypes) {\n if (includesType(withTypes, t)) ts.push(t)\n else if (withTypes.includes(\"integer\") && t === \"number\") ts.push(\"integer\")\n }\n it.dataTypes = ts\n}\n\nfunction strictTypesError(it: SchemaObjCxt, msg: string): void {\n const schemaPath = it.schemaEnv.baseId + it.errSchemaPath\n msg += ` at \"${schemaPath}\" (strictTypes)`\n checkStrictMode(it, msg, it.opts.strictTypes)\n}\n\nexport class KeywordCxt implements KeywordErrorCxt {\n readonly gen: CodeGen\n readonly allErrors?: boolean\n readonly keyword: string\n readonly data: Name // Name referencing the current level of the data instance\n readonly $data?: string | false\n schema: any // keyword value in the schema\n readonly schemaValue: Code | number | boolean // Code reference to keyword schema value or primitive value\n readonly schemaCode: Code | number | boolean // Code reference to resolved schema value (different if schema is $data)\n readonly schemaType: JSONType[] // allowed type(s) of keyword value in the schema\n readonly parentSchema: AnySchemaObject\n readonly errsCount?: Name // Name reference to the number of validation errors collected before this keyword,\n // requires option trackErrors in keyword definition\n params: KeywordCxtParams // object to pass parameters to error messages from keyword code\n readonly it: SchemaObjCxt // schema compilation context (schema is guaranteed to be an object, not boolean)\n readonly def: AddedKeywordDefinition\n\n constructor(it: SchemaObjCxt, def: AddedKeywordDefinition, keyword: string) {\n validateKeywordUsage(it, def, keyword)\n this.gen = it.gen\n this.allErrors = it.allErrors\n this.keyword = keyword\n this.data = it.data\n this.schema = it.schema[keyword]\n this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data\n this.schemaValue = schemaRefOrVal(it, this.schema, keyword, this.$data)\n this.schemaType = def.schemaType\n this.parentSchema = it.schema\n this.params = {}\n this.it = it\n this.def = def\n\n if (this.$data) {\n this.schemaCode = it.gen.const(\"vSchema\", getData(this.$data, it))\n } else {\n this.schemaCode = this.schemaValue\n if (!validSchemaType(this.schema, def.schemaType, def.allowUndefined)) {\n throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`)\n }\n }\n\n if (\"code\" in def ? def.trackErrors : def.errors !== false) {\n this.errsCount = it.gen.const(\"_errs\", N.errors)\n }\n }\n\n result(condition: Code, successAction?: () => void, failAction?: () => void): void {\n this.failResult(not(condition), successAction, failAction)\n }\n\n failResult(condition: Code, successAction?: () => void, failAction?: () => void): void {\n this.gen.if(condition)\n if (failAction) failAction()\n else this.error()\n if (successAction) {\n this.gen.else()\n successAction()\n if (this.allErrors) this.gen.endIf()\n } else {\n if (this.allErrors) this.gen.endIf()\n else this.gen.else()\n }\n }\n\n pass(condition: Code, failAction?: () => void): void {\n this.failResult(not(condition), undefined, failAction)\n }\n\n fail(condition?: Code): void {\n if (condition === undefined) {\n this.error()\n if (!this.allErrors) this.gen.if(false) // this branch will be removed by gen.optimize\n return\n }\n this.gen.if(condition)\n this.error()\n if (this.allErrors) this.gen.endIf()\n else this.gen.else()\n }\n\n fail$data(condition: Code): void {\n if (!this.$data) return this.fail(condition)\n const {schemaCode} = this\n this.fail(_`${schemaCode} !== undefined && (${or(this.invalid$data(), condition)})`)\n }\n\n error(append?: boolean, errorParams?: KeywordCxtParams, errorPaths?: ErrorPaths): void {\n if (errorParams) {\n this.setParams(errorParams)\n this._error(append, errorPaths)\n this.setParams({})\n return\n }\n this._error(append, errorPaths)\n }\n\n private _error(append?: boolean, errorPaths?: ErrorPaths): void {\n ;(append ? reportExtraError : reportError)(this, this.def.error, errorPaths)\n }\n\n $dataError(): void {\n reportError(this, this.def.$dataError || keyword$DataError)\n }\n\n reset(): void {\n if (this.errsCount === undefined) throw new Error('add \"trackErrors\" to keyword definition')\n resetErrorsCount(this.gen, this.errsCount)\n }\n\n ok(cond: Code | boolean): void {\n if (!this.allErrors) this.gen.if(cond)\n }\n\n setParams(obj: KeywordCxtParams, assign?: true): void {\n if (assign) Object.assign(this.params, obj)\n else this.params = obj\n }\n\n block$data(valid: Name, codeBlock: () => void, $dataValid: Code = nil): void {\n this.gen.block(() => {\n this.check$data(valid, $dataValid)\n codeBlock()\n })\n }\n\n check$data(valid: Name = nil, $dataValid: Code = nil): void {\n if (!this.$data) return\n const {gen, schemaCode, schemaType, def} = this\n gen.if(or(_`${schemaCode} === undefined`, $dataValid))\n if (valid !== nil) gen.assign(valid, true)\n if (schemaType.length || def.validateSchema) {\n gen.elseIf(this.invalid$data())\n this.$dataError()\n if (valid !== nil) gen.assign(valid, false)\n }\n gen.else()\n }\n\n invalid$data(): Code {\n const {gen, schemaCode, schemaType, def, it} = this\n return or(wrong$DataType(), invalid$DataSchema())\n\n function wrong$DataType(): Code {\n if (schemaType.length) {\n /* istanbul ignore if */\n if (!(schemaCode instanceof Name)) throw new Error(\"ajv implementation error\")\n const st = Array.isArray(schemaType) ? schemaType : [schemaType]\n return _`${checkDataTypes(st, schemaCode, it.opts.strictNumbers, DataType.Wrong)}`\n }\n return nil\n }\n\n function invalid$DataSchema(): Code {\n if (def.validateSchema) {\n const validateSchemaRef = gen.scopeValue(\"validate$data\", {ref: def.validateSchema}) // TODO value.code for standalone\n return _`!${validateSchemaRef}(${schemaCode})`\n }\n return nil\n }\n }\n\n subschema(appl: SubschemaArgs, valid: Name): SchemaCxt {\n const subschema = getSubschema(this.it, appl)\n extendSubschemaData(subschema, this.it, appl)\n extendSubschemaMode(subschema, appl)\n const nextContext = {...this.it, ...subschema, items: undefined, props: undefined}\n subschemaCode(nextContext, valid)\n return nextContext\n }\n\n mergeEvaluated(schemaCxt: SchemaCxt, toName?: typeof Name): void {\n const {it, gen} = this\n if (!it.opts.unevaluated) return\n if (it.props !== true && schemaCxt.props !== undefined) {\n it.props = mergeEvaluated.props(gen, schemaCxt.props, it.props, toName)\n }\n if (it.items !== true && schemaCxt.items !== undefined) {\n it.items = mergeEvaluated.items(gen, schemaCxt.items, it.items, toName)\n }\n }\n\n mergeValidEvaluated(schemaCxt: SchemaCxt, valid: Name): boolean | void {\n const {it, gen} = this\n if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {\n gen.if(valid, () => this.mergeEvaluated(schemaCxt, Name))\n return true\n }\n }\n}\n\nfunction keywordCode(\n it: SchemaObjCxt,\n keyword: string,\n def: AddedKeywordDefinition,\n ruleType?: JSONType\n): void {\n const cxt = new KeywordCxt(it, def, keyword)\n if (\"code\" in def) {\n def.code(cxt, ruleType)\n } else if (cxt.$data && def.validate) {\n funcKeywordCode(cxt, def)\n } else if (\"macro\" in def) {\n macroKeywordCode(cxt, def)\n } else if (def.compile || def.validate) {\n funcKeywordCode(cxt, def)\n }\n}\n\nconst JSON_POINTER = /^\\/(?:[^~]|~0|~1)*$/\nconst RELATIVE_JSON_POINTER = /^([0-9]+)(#|\\/(?:[^~]|~0|~1)*)?$/\nexport function getData(\n $data: string,\n {dataLevel, dataNames, dataPathArr}: SchemaCxt\n): Code | number {\n let jsonPointer\n let data: Code\n if ($data === \"\") return N.rootData\n if ($data[0] === \"/\") {\n if (!JSON_POINTER.test($data)) throw new Error(`Invalid JSON-pointer: ${$data}`)\n jsonPointer = $data\n data = N.rootData\n } else {\n const matches = RELATIVE_JSON_POINTER.exec($data)\n if (!matches) throw new Error(`Invalid JSON-pointer: ${$data}`)\n const up: number = +matches[1]\n jsonPointer = matches[2]\n if (jsonPointer === \"#\") {\n if (up >= dataLevel) throw new Error(errorMsg(\"property/index\", up))\n return dataPathArr[dataLevel - up]\n }\n if (up > dataLevel) throw new Error(errorMsg(\"data\", up))\n data = dataNames[dataLevel - up]\n if (!jsonPointer) return data\n }\n\n let expr = data\n const segments = jsonPointer.split(\"/\")\n for (const segment of segments) {\n if (segment) {\n data = _`${data}${getProperty(unescapeJsonPointer(segment))}`\n expr = _`${expr} && ${data}`\n }\n }\n return expr\n\n function errorMsg(pointerType: string, up: number): string {\n return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`\n }\n}\n", "import type {ErrorObject} from \"../types\"\n\nexport default class ValidationError extends Error {\n readonly errors: Partial[]\n readonly ajv: true\n readonly validation: true\n\n constructor(errors: Partial[]) {\n super(\"validation failed\")\n this.errors = errors\n this.ajv = this.validation = true\n }\n}\n", "import {resolveUrl, normalizeId, getFullPath} from \"./resolve\"\nimport type {UriResolver} from \"../types\"\n\nexport default class MissingRefError extends Error {\n readonly missingRef: string\n readonly missingSchema: string\n\n constructor(resolver: UriResolver, baseId: string, ref: string, msg?: string) {\n super(msg || `can't resolve reference ${ref} from id ${baseId}`)\n this.missingRef = resolveUrl(resolver, baseId, ref)\n this.missingSchema = normalizeId(getFullPath(resolver, this.missingRef))\n }\n}\n", "import type {\n AnySchema,\n AnySchemaObject,\n AnyValidateFunction,\n AsyncValidateFunction,\n EvaluatedProperties,\n EvaluatedItems,\n} from \"../types\"\nimport type Ajv from \"../core\"\nimport type {InstanceOptions} from \"../core\"\nimport {CodeGen, _, nil, stringify, Name, Code, ValueScopeName} from \"./codegen\"\nimport ValidationError from \"../runtime/validation_error\"\nimport N from \"./names\"\nimport {LocalRefs, getFullPath, _getFullPath, inlineRef, normalizeId, resolveUrl} from \"./resolve\"\nimport {schemaHasRulesButRef, unescapeFragment} from \"./util\"\nimport {validateFunctionCode} from \"./validate\"\nimport {URIComponent} from \"fast-uri\"\nimport {JSONType} from \"./rules\"\n\nexport type SchemaRefs = {\n [Ref in string]?: SchemaEnv | AnySchema\n}\n\nexport interface SchemaCxt {\n readonly gen: CodeGen\n readonly allErrors?: boolean // validation mode - whether to collect all errors or break on error\n readonly data: Name // Name with reference to the current part of data instance\n readonly parentData: Name // should be used in keywords modifying data\n readonly parentDataProperty: Code | number // should be used in keywords modifying data\n readonly dataNames: Name[]\n readonly dataPathArr: (Code | number)[]\n readonly dataLevel: number // the level of the currently validated data,\n // it can be used to access both the property names and the data on all levels from the top.\n dataTypes: JSONType[] // data types applied to the current part of data instance\n definedProperties: Set // set of properties to keep track of for required checks\n readonly topSchemaRef: Code\n readonly validateName: Name\n evaluated?: Name\n readonly ValidationError?: Name\n readonly schema: AnySchema // current schema object - equal to parentSchema passed via KeywordCxt\n readonly schemaEnv: SchemaEnv\n readonly rootId: string\n baseId: string // the current schema base URI that should be used as the base for resolving URIs in references (\\$ref)\n readonly schemaPath: Code // the run-time expression that evaluates to the property name of the current schema\n readonly errSchemaPath: string // this is actual string, should not be changed to Code\n readonly errorPath: Code\n readonly propertyName?: Name\n readonly compositeRule?: boolean // true indicates that the current schema is inside the compound keyword,\n // where failing some rule doesn't mean validation failure (`anyOf`, `oneOf`, `not`, `if`).\n // This flag is used to determine whether you can return validation result immediately after any error in case the option `allErrors` is not `true.\n // You only need to use it if you have many steps in your keywords and potentially can define multiple errors.\n props?: EvaluatedProperties | Name // properties evaluated by this schema - used by parent schema or assigned to validation function\n items?: EvaluatedItems | Name // last item evaluated by this schema - used by parent schema or assigned to validation function\n jtdDiscriminator?: string\n jtdMetadata?: boolean\n readonly createErrors?: boolean\n readonly opts: InstanceOptions // Ajv instance option.\n readonly self: Ajv // current Ajv instance\n}\n\nexport interface SchemaObjCxt extends SchemaCxt {\n readonly schema: AnySchemaObject\n}\ninterface SchemaEnvArgs {\n readonly schema: AnySchema\n readonly schemaId?: \"$id\" | \"id\"\n readonly root?: SchemaEnv\n readonly baseId?: string\n readonly schemaPath?: string\n readonly localRefs?: LocalRefs\n readonly meta?: boolean\n}\n\nexport class SchemaEnv implements SchemaEnvArgs {\n readonly schema: AnySchema\n readonly schemaId?: \"$id\" | \"id\"\n readonly root: SchemaEnv\n baseId: string // TODO possibly, it should be readonly\n schemaPath?: string\n localRefs?: LocalRefs\n readonly meta?: boolean\n readonly $async?: boolean // true if the current schema is asynchronous.\n readonly refs: SchemaRefs = {}\n readonly dynamicAnchors: {[Ref in string]?: true} = {}\n validate?: AnyValidateFunction\n validateName?: ValueScopeName\n serialize?: (data: unknown) => string\n serializeName?: ValueScopeName\n parse?: (data: string) => unknown\n parseName?: ValueScopeName\n\n constructor(env: SchemaEnvArgs) {\n let schema: AnySchemaObject | undefined\n if (typeof env.schema == \"object\") schema = env.schema\n this.schema = env.schema\n this.schemaId = env.schemaId\n this.root = env.root || this\n this.baseId = env.baseId ?? normalizeId(schema?.[env.schemaId || \"$id\"])\n this.schemaPath = env.schemaPath\n this.localRefs = env.localRefs\n this.meta = env.meta\n this.$async = schema?.$async\n this.refs = {}\n }\n}\n\n// let codeSize = 0\n// let nodeCount = 0\n\n// Compiles schema in SchemaEnv\nexport function compileSchema(this: Ajv, sch: SchemaEnv): SchemaEnv {\n // TODO refactor - remove compilations\n const _sch = getCompilingSchema.call(this, sch)\n if (_sch) return _sch\n const rootId = getFullPath(this.opts.uriResolver, sch.root.baseId) // TODO if getFullPath removed 1 tests fails\n const {es5, lines} = this.opts.code\n const {ownProperties} = this.opts\n const gen = new CodeGen(this.scope, {es5, lines, ownProperties})\n let _ValidationError\n if (sch.$async) {\n _ValidationError = gen.scopeValue(\"Error\", {\n ref: ValidationError,\n code: _`require(\"ajv/dist/runtime/validation_error\").default`,\n })\n }\n\n const validateName = gen.scopeName(\"validate\")\n sch.validateName = validateName\n\n const schemaCxt: SchemaCxt = {\n gen,\n allErrors: this.opts.allErrors,\n data: N.data,\n parentData: N.parentData,\n parentDataProperty: N.parentDataProperty,\n dataNames: [N.data],\n dataPathArr: [nil], // TODO can its length be used as dataLevel if nil is removed?\n dataLevel: 0,\n dataTypes: [],\n definedProperties: new Set(),\n topSchemaRef: gen.scopeValue(\n \"schema\",\n this.opts.code.source === true\n ? {ref: sch.schema, code: stringify(sch.schema)}\n : {ref: sch.schema}\n ),\n validateName,\n ValidationError: _ValidationError,\n schema: sch.schema,\n schemaEnv: sch,\n rootId,\n baseId: sch.baseId || rootId,\n schemaPath: nil,\n errSchemaPath: sch.schemaPath || (this.opts.jtd ? \"\" : \"#\"),\n errorPath: _`\"\"`,\n opts: this.opts,\n self: this,\n }\n\n let sourceCode: string | undefined\n try {\n this._compilations.add(sch)\n validateFunctionCode(schemaCxt)\n gen.optimize(this.opts.code.optimize)\n // gen.optimize(1)\n const validateCode = gen.toString()\n sourceCode = `${gen.scopeRefs(N.scope)}return ${validateCode}`\n // console.log((codeSize += sourceCode.length), (nodeCount += gen.nodeCount))\n if (this.opts.code.process) sourceCode = this.opts.code.process(sourceCode, sch)\n // console.log(\"\\n\\n\\n *** \\n\", sourceCode)\n const makeValidate = new Function(`${N.self}`, `${N.scope}`, sourceCode)\n const validate: AnyValidateFunction = makeValidate(this, this.scope.get())\n this.scope.value(validateName, {ref: validate})\n\n validate.errors = null\n validate.schema = sch.schema\n validate.schemaEnv = sch\n if (sch.$async) (validate as AsyncValidateFunction).$async = true\n if (this.opts.code.source === true) {\n validate.source = {validateName, validateCode, scopeValues: gen._values}\n }\n if (this.opts.unevaluated) {\n const {props, items} = schemaCxt\n validate.evaluated = {\n props: props instanceof Name ? undefined : props,\n items: items instanceof Name ? undefined : items,\n dynamicProps: props instanceof Name,\n dynamicItems: items instanceof Name,\n }\n if (validate.source) validate.source.evaluated = stringify(validate.evaluated)\n }\n sch.validate = validate\n return sch\n } catch (e) {\n delete sch.validate\n delete sch.validateName\n if (sourceCode) this.logger.error(\"Error compiling schema, function code:\", sourceCode)\n // console.log(\"\\n\\n\\n *** \\n\", sourceCode, this.opts)\n throw e\n } finally {\n this._compilations.delete(sch)\n }\n}\n\nexport function resolveRef(\n this: Ajv,\n root: SchemaEnv,\n baseId: string,\n ref: string\n): AnySchema | SchemaEnv | undefined {\n ref = resolveUrl(this.opts.uriResolver, baseId, ref)\n const schOrFunc = root.refs[ref]\n if (schOrFunc) return schOrFunc\n\n let _sch = resolve.call(this, root, ref)\n if (_sch === undefined) {\n const schema = root.localRefs?.[ref] // TODO maybe localRefs should hold SchemaEnv\n const {schemaId} = this.opts\n if (schema) _sch = new SchemaEnv({schema, schemaId, root, baseId})\n }\n\n if (_sch === undefined) return\n return (root.refs[ref] = inlineOrCompile.call(this, _sch))\n}\n\nfunction inlineOrCompile(this: Ajv, sch: SchemaEnv): AnySchema | SchemaEnv {\n if (inlineRef(sch.schema, this.opts.inlineRefs)) return sch.schema\n return sch.validate ? sch : compileSchema.call(this, sch)\n}\n\n// Index of schema compilation in the currently compiled list\nexport function getCompilingSchema(this: Ajv, schEnv: SchemaEnv): SchemaEnv | void {\n for (const sch of this._compilations) {\n if (sameSchemaEnv(sch, schEnv)) return sch\n }\n}\n\nfunction sameSchemaEnv(s1: SchemaEnv, s2: SchemaEnv): boolean {\n return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId\n}\n\n// resolve and compile the references ($ref)\n// TODO returns AnySchemaObject (if the schema can be inlined) or validation function\nfunction resolve(\n this: Ajv,\n root: SchemaEnv, // information about the root schema for the current schema\n ref: string // reference to resolve\n): SchemaEnv | undefined {\n let sch\n while (typeof (sch = this.refs[ref]) == \"string\") ref = sch\n return sch || this.schemas[ref] || resolveSchema.call(this, root, ref)\n}\n\n// Resolve schema, its root and baseId\nexport function resolveSchema(\n this: Ajv,\n root: SchemaEnv, // root object with properties schema, refs TODO below SchemaEnv is assigned to it\n ref: string // reference to resolve\n): SchemaEnv | undefined {\n const p = this.opts.uriResolver.parse(ref)\n const refPath = _getFullPath(this.opts.uriResolver, p)\n let baseId = getFullPath(this.opts.uriResolver, root.baseId, undefined)\n // TODO `Object.keys(root.schema).length > 0` should not be needed - but removing breaks 2 tests\n if (Object.keys(root.schema).length > 0 && refPath === baseId) {\n return getJsonPointer.call(this, p, root)\n }\n\n const id = normalizeId(refPath)\n const schOrRef = this.refs[id] || this.schemas[id]\n if (typeof schOrRef == \"string\") {\n const sch = resolveSchema.call(this, root, schOrRef)\n if (typeof sch?.schema !== \"object\") return\n return getJsonPointer.call(this, p, sch)\n }\n\n if (typeof schOrRef?.schema !== \"object\") return\n if (!schOrRef.validate) compileSchema.call(this, schOrRef)\n if (id === normalizeId(ref)) {\n const {schema} = schOrRef\n const {schemaId} = this.opts\n const schId = schema[schemaId]\n if (schId) baseId = resolveUrl(this.opts.uriResolver, baseId, schId)\n return new SchemaEnv({schema, schemaId, root, baseId})\n }\n return getJsonPointer.call(this, p, schOrRef)\n}\n\nconst PREVENT_SCOPE_CHANGE = new Set([\n \"properties\",\n \"patternProperties\",\n \"enum\",\n \"dependencies\",\n \"definitions\",\n])\n\nfunction getJsonPointer(\n this: Ajv,\n parsedRef: URIComponent,\n {baseId, schema, root}: SchemaEnv\n): SchemaEnv | undefined {\n if (parsedRef.fragment?.[0] !== \"/\") return\n for (const part of parsedRef.fragment.slice(1).split(\"/\")) {\n if (typeof schema === \"boolean\") return\n const partSchema = schema[unescapeFragment(part)]\n if (partSchema === undefined) return\n schema = partSchema\n // TODO PREVENT_SCOPE_CHANGE could be defined in keyword def?\n const schId = typeof schema === \"object\" && schema[this.opts.schemaId]\n if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {\n baseId = resolveUrl(this.opts.uriResolver, baseId, schId)\n }\n }\n let env: SchemaEnv | undefined\n if (typeof schema != \"boolean\" && schema.$ref && !schemaHasRulesButRef(schema, this.RULES)) {\n const $ref = resolveUrl(this.opts.uriResolver, baseId, schema.$ref)\n env = resolveSchema.call(this, root, $ref)\n }\n // even though resolution failed we need to return SchemaEnv to throw exception\n // so that compileAsync loads missing schema.\n const {schemaId} = this.opts\n env = env || new SchemaEnv({schema, schemaId, root, baseId})\n if (env.schema !== env.root.schema) return env\n return undefined\n}\n", "{\n \"$id\": \"https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#\",\n \"description\": \"Meta-schema for $data reference (JSON AnySchema extension proposal)\",\n \"type\": \"object\",\n \"required\": [\"$data\"],\n \"properties\": {\n \"$data\": {\n \"type\": \"string\",\n \"anyOf\": [{\"format\": \"relative-json-pointer\"}, {\"format\": \"json-pointer\"}]\n }\n },\n \"additionalProperties\": false\n}\n", "'use strict'\n\n/** @type {(value: string) => boolean} */\nconst isUUID = RegExp.prototype.test.bind(/^[\\da-f]{8}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{12}$/iu)\n\n/** @type {(value: string) => boolean} */\nconst 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)\n\n/**\n * @param {Array} input\n * @returns {string}\n */\nfunction stringArrayToHexStripped (input) {\n let acc = ''\n let code = 0\n let i = 0\n\n for (i = 0; i < input.length; i++) {\n code = input[i].charCodeAt(0)\n if (code === 48) {\n continue\n }\n if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {\n return ''\n }\n acc += input[i]\n break\n }\n\n for (i += 1; i < input.length; i++) {\n code = input[i].charCodeAt(0)\n if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {\n return ''\n }\n acc += input[i]\n }\n return acc\n}\n\n/**\n * @typedef {Object} GetIPV6Result\n * @property {boolean} error - Indicates if there was an error parsing the IPv6 address.\n * @property {string} address - The parsed IPv6 address.\n * @property {string} [zone] - The zone identifier, if present.\n */\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nconst nonSimpleDomain = RegExp.prototype.test.bind(/[^!\"$&'()*+,\\-.;=_`a-z{}~]/u)\n\n/**\n * @param {Array} buffer\n * @returns {boolean}\n */\nfunction consumeIsZone (buffer) {\n buffer.length = 0\n return true\n}\n\n/**\n * @param {Array} buffer\n * @param {Array} address\n * @param {GetIPV6Result} output\n * @returns {boolean}\n */\nfunction consumeHextets (buffer, address, output) {\n if (buffer.length) {\n const hex = stringArrayToHexStripped(buffer)\n if (hex !== '') {\n address.push(hex)\n } else {\n output.error = true\n return false\n }\n buffer.length = 0\n }\n return true\n}\n\n/**\n * @param {string} input\n * @returns {GetIPV6Result}\n */\nfunction getIPV6 (input) {\n let tokenCount = 0\n const output = { error: false, address: '', zone: '' }\n /** @type {Array} */\n const address = []\n /** @type {Array} */\n const buffer = []\n let endipv6Encountered = false\n let endIpv6 = false\n\n let consume = consumeHextets\n\n for (let i = 0; i < input.length; i++) {\n const cursor = input[i]\n if (cursor === '[' || cursor === ']') { continue }\n if (cursor === ':') {\n if (endipv6Encountered === true) {\n endIpv6 = true\n }\n if (!consume(buffer, address, output)) { break }\n if (++tokenCount > 7) {\n // not valid\n output.error = true\n break\n }\n if (i > 0 && input[i - 1] === ':') {\n endipv6Encountered = true\n }\n address.push(':')\n continue\n } else if (cursor === '%') {\n if (!consume(buffer, address, output)) { break }\n // switch to zone detection\n consume = consumeIsZone\n } else {\n buffer.push(cursor)\n continue\n }\n }\n if (buffer.length) {\n if (consume === consumeIsZone) {\n output.zone = buffer.join('')\n } else if (endIpv6) {\n address.push(buffer.join(''))\n } else {\n address.push(stringArrayToHexStripped(buffer))\n }\n }\n output.address = address.join('')\n return output\n}\n\n/**\n * @typedef {Object} NormalizeIPv6Result\n * @property {string} host - The normalized host.\n * @property {string} [escapedHost] - The escaped host.\n * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.\n */\n\n/**\n * @param {string} host\n * @returns {NormalizeIPv6Result}\n */\nfunction normalizeIPv6 (host) {\n if (findToken(host, ':') < 2) { return { host, isIPV6: false } }\n const ipv6 = getIPV6(host)\n\n if (!ipv6.error) {\n let newHost = ipv6.address\n let escapedHost = ipv6.address\n if (ipv6.zone) {\n newHost += '%' + ipv6.zone\n escapedHost += '%25' + ipv6.zone\n }\n return { host: newHost, isIPV6: true, escapedHost }\n } else {\n return { host, isIPV6: false }\n }\n}\n\n/**\n * @param {string} str\n * @param {string} token\n * @returns {number}\n */\nfunction findToken (str, token) {\n let ind = 0\n for (let i = 0; i < str.length; i++) {\n if (str[i] === token) ind++\n }\n return ind\n}\n\n/**\n * @param {string} path\n * @returns {string}\n *\n * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4\n */\nfunction removeDotSegments (path) {\n let input = path\n const output = []\n let nextSlash = -1\n let len = 0\n\n // eslint-disable-next-line no-cond-assign\n while (len = input.length) {\n if (len === 1) {\n if (input === '.') {\n break\n } else if (input === '/') {\n output.push('/')\n break\n } else {\n output.push(input)\n break\n }\n } else if (len === 2) {\n if (input[0] === '.') {\n if (input[1] === '.') {\n break\n } else if (input[1] === '/') {\n input = input.slice(2)\n continue\n }\n } else if (input[0] === '/') {\n if (input[1] === '.' || input[1] === '/') {\n output.push('/')\n break\n }\n }\n } else if (len === 3) {\n if (input === '/..') {\n if (output.length !== 0) {\n output.pop()\n }\n output.push('/')\n break\n }\n }\n if (input[0] === '.') {\n if (input[1] === '.') {\n if (input[2] === '/') {\n input = input.slice(3)\n continue\n }\n } else if (input[1] === '/') {\n input = input.slice(2)\n continue\n }\n } else if (input[0] === '/') {\n if (input[1] === '.') {\n if (input[2] === '/') {\n input = input.slice(2)\n continue\n } else if (input[2] === '.') {\n if (input[3] === '/') {\n input = input.slice(3)\n if (output.length !== 0) {\n output.pop()\n }\n continue\n }\n }\n }\n }\n\n // Rule 2E: Move normal path segment to output\n if ((nextSlash = input.indexOf('/', 1)) === -1) {\n output.push(input)\n break\n } else {\n output.push(input.slice(0, nextSlash))\n input = input.slice(nextSlash)\n }\n }\n\n return output.join('')\n}\n\n/**\n * @param {import('../types/index').URIComponent} component\n * @param {boolean} esc\n * @returns {import('../types/index').URIComponent}\n */\nfunction normalizeComponentEncoding (component, esc) {\n const func = esc !== true ? escape : unescape\n if (component.scheme !== undefined) {\n component.scheme = func(component.scheme)\n }\n if (component.userinfo !== undefined) {\n component.userinfo = func(component.userinfo)\n }\n if (component.host !== undefined) {\n component.host = func(component.host)\n }\n if (component.path !== undefined) {\n component.path = func(component.path)\n }\n if (component.query !== undefined) {\n component.query = func(component.query)\n }\n if (component.fragment !== undefined) {\n component.fragment = func(component.fragment)\n }\n return component\n}\n\n/**\n * @param {import('../types/index').URIComponent} component\n * @returns {string|undefined}\n */\nfunction recomposeAuthority (component) {\n const uriTokens = []\n\n if (component.userinfo !== undefined) {\n uriTokens.push(component.userinfo)\n uriTokens.push('@')\n }\n\n if (component.host !== undefined) {\n let host = unescape(component.host)\n if (!isIPv4(host)) {\n const ipV6res = normalizeIPv6(host)\n if (ipV6res.isIPV6 === true) {\n host = `[${ipV6res.escapedHost}]`\n } else {\n host = component.host\n }\n }\n uriTokens.push(host)\n }\n\n if (typeof component.port === 'number' || typeof component.port === 'string') {\n uriTokens.push(':')\n uriTokens.push(String(component.port))\n }\n\n return uriTokens.length ? uriTokens.join('') : undefined\n};\n\nmodule.exports = {\n nonSimpleDomain,\n recomposeAuthority,\n normalizeComponentEncoding,\n removeDotSegments,\n isIPv4,\n isUUID,\n normalizeIPv6,\n stringArrayToHexStripped\n}\n", "'use strict'\n\nconst { isUUID } = require('./utils')\nconst URN_REG = /([\\da-z][\\d\\-a-z]{0,31}):((?:[\\w!$'()*+,\\-.:;=@]|%[\\da-f]{2})+)/iu\n\nconst supportedSchemeNames = /** @type {const} */ (['http', 'https', 'ws',\n 'wss', 'urn', 'urn:uuid'])\n\n/** @typedef {supportedSchemeNames[number]} SchemeName */\n\n/**\n * @param {string} name\n * @returns {name is SchemeName}\n */\nfunction isValidSchemeName (name) {\n return supportedSchemeNames.indexOf(/** @type {*} */ (name)) !== -1\n}\n\n/**\n * @callback SchemeFn\n * @param {import('../types/index').URIComponent} component\n * @param {import('../types/index').Options} options\n * @returns {import('../types/index').URIComponent}\n */\n\n/**\n * @typedef {Object} SchemeHandler\n * @property {SchemeName} scheme - The scheme name.\n * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.\n * @property {SchemeFn} parse - Function to parse the URI component for this scheme.\n * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.\n * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.\n * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.\n * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.\n */\n\n/**\n * @param {import('../types/index').URIComponent} wsComponent\n * @returns {boolean}\n */\nfunction wsIsSecure (wsComponent) {\n if (wsComponent.secure === true) {\n return true\n } else if (wsComponent.secure === false) {\n return false\n } else if (wsComponent.scheme) {\n return (\n wsComponent.scheme.length === 3 &&\n (wsComponent.scheme[0] === 'w' || wsComponent.scheme[0] === 'W') &&\n (wsComponent.scheme[1] === 's' || wsComponent.scheme[1] === 'S') &&\n (wsComponent.scheme[2] === 's' || wsComponent.scheme[2] === 'S')\n )\n } else {\n return false\n }\n}\n\n/** @type {SchemeFn} */\nfunction httpParse (component) {\n if (!component.host) {\n component.error = component.error || 'HTTP URIs must have a host.'\n }\n\n return component\n}\n\n/** @type {SchemeFn} */\nfunction httpSerialize (component) {\n const secure = String(component.scheme).toLowerCase() === 'https'\n\n // normalize the default port\n if (component.port === (secure ? 443 : 80) || component.port === '') {\n component.port = undefined\n }\n\n // normalize the empty path\n if (!component.path) {\n component.path = '/'\n }\n\n // NOTE: We do not parse query strings for HTTP URIs\n // as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n // and not the HTTP spec.\n\n return component\n}\n\n/** @type {SchemeFn} */\nfunction wsParse (wsComponent) {\n// indicate if the secure flag is set\n wsComponent.secure = wsIsSecure(wsComponent)\n\n // construct resouce name\n wsComponent.resourceName = (wsComponent.path || '/') + (wsComponent.query ? '?' + wsComponent.query : '')\n wsComponent.path = undefined\n wsComponent.query = undefined\n\n return wsComponent\n}\n\n/** @type {SchemeFn} */\nfunction wsSerialize (wsComponent) {\n// normalize the default port\n if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === '') {\n wsComponent.port = undefined\n }\n\n // ensure scheme matches secure flag\n if (typeof wsComponent.secure === 'boolean') {\n wsComponent.scheme = (wsComponent.secure ? 'wss' : 'ws')\n wsComponent.secure = undefined\n }\n\n // reconstruct path from resource name\n if (wsComponent.resourceName) {\n const [path, query] = wsComponent.resourceName.split('?')\n wsComponent.path = (path && path !== '/' ? path : undefined)\n wsComponent.query = query\n wsComponent.resourceName = undefined\n }\n\n // forbid fragment component\n wsComponent.fragment = undefined\n\n return wsComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnParse (urnComponent, options) {\n if (!urnComponent.path) {\n urnComponent.error = 'URN can not be parsed'\n return urnComponent\n }\n const matches = urnComponent.path.match(URN_REG)\n if (matches) {\n const scheme = options.scheme || urnComponent.scheme || 'urn'\n urnComponent.nid = matches[1].toLowerCase()\n urnComponent.nss = matches[2]\n const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`\n const schemeHandler = getSchemeHandler(urnScheme)\n urnComponent.path = undefined\n\n if (schemeHandler) {\n urnComponent = schemeHandler.parse(urnComponent, options)\n }\n } else {\n urnComponent.error = urnComponent.error || 'URN can not be parsed.'\n }\n\n return urnComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnSerialize (urnComponent, options) {\n if (urnComponent.nid === undefined) {\n throw new Error('URN without nid cannot be serialized')\n }\n const scheme = options.scheme || urnComponent.scheme || 'urn'\n const nid = urnComponent.nid.toLowerCase()\n const urnScheme = `${scheme}:${options.nid || nid}`\n const schemeHandler = getSchemeHandler(urnScheme)\n\n if (schemeHandler) {\n urnComponent = schemeHandler.serialize(urnComponent, options)\n }\n\n const uriComponent = urnComponent\n const nss = urnComponent.nss\n uriComponent.path = `${nid || options.nid}:${nss}`\n\n options.skipEscape = true\n return uriComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnuuidParse (urnComponent, options) {\n const uuidComponent = urnComponent\n uuidComponent.uuid = uuidComponent.nss\n uuidComponent.nss = undefined\n\n if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {\n uuidComponent.error = uuidComponent.error || 'UUID is not valid.'\n }\n\n return uuidComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnuuidSerialize (uuidComponent) {\n const urnComponent = uuidComponent\n // normalize UUID\n urnComponent.nss = (uuidComponent.uuid || '').toLowerCase()\n return urnComponent\n}\n\nconst http = /** @type {SchemeHandler} */ ({\n scheme: 'http',\n domainHost: true,\n parse: httpParse,\n serialize: httpSerialize\n})\n\nconst https = /** @type {SchemeHandler} */ ({\n scheme: 'https',\n domainHost: http.domainHost,\n parse: httpParse,\n serialize: httpSerialize\n})\n\nconst ws = /** @type {SchemeHandler} */ ({\n scheme: 'ws',\n domainHost: true,\n parse: wsParse,\n serialize: wsSerialize\n})\n\nconst wss = /** @type {SchemeHandler} */ ({\n scheme: 'wss',\n domainHost: ws.domainHost,\n parse: ws.parse,\n serialize: ws.serialize\n})\n\nconst urn = /** @type {SchemeHandler} */ ({\n scheme: 'urn',\n parse: urnParse,\n serialize: urnSerialize,\n skipNormalize: true\n})\n\nconst urnuuid = /** @type {SchemeHandler} */ ({\n scheme: 'urn:uuid',\n parse: urnuuidParse,\n serialize: urnuuidSerialize,\n skipNormalize: true\n})\n\nconst SCHEMES = /** @type {Record} */ ({\n http,\n https,\n ws,\n wss,\n urn,\n 'urn:uuid': urnuuid\n})\n\nObject.setPrototypeOf(SCHEMES, null)\n\n/**\n * @param {string|undefined} scheme\n * @returns {SchemeHandler|undefined}\n */\nfunction getSchemeHandler (scheme) {\n return (\n scheme && (\n SCHEMES[/** @type {SchemeName} */ (scheme)] ||\n SCHEMES[/** @type {SchemeName} */(scheme.toLowerCase())])\n ) ||\n undefined\n}\n\nmodule.exports = {\n wsIsSecure,\n SCHEMES,\n isValidSchemeName,\n getSchemeHandler,\n}\n", "'use strict'\n\nconst { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require('./lib/utils')\nconst { SCHEMES, getSchemeHandler } = require('./lib/schemes')\n\n/**\n * @template {import('./types/index').URIComponent|string} T\n * @param {T} uri\n * @param {import('./types/index').Options} [options]\n * @returns {T}\n */\nfunction normalize (uri, options) {\n if (typeof uri === 'string') {\n uri = /** @type {T} */ (serialize(parse(uri, options), options))\n } else if (typeof uri === 'object') {\n uri = /** @type {T} */ (parse(serialize(uri, options), options))\n }\n return uri\n}\n\n/**\n * @param {string} baseURI\n * @param {string} relativeURI\n * @param {import('./types/index').Options} [options]\n * @returns {string}\n */\nfunction resolve (baseURI, relativeURI, options) {\n const schemelessOptions = options ? Object.assign({ scheme: 'null' }, options) : { scheme: 'null' }\n const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true)\n schemelessOptions.skipEscape = true\n return serialize(resolved, schemelessOptions)\n}\n\n/**\n * @param {import ('./types/index').URIComponent} base\n * @param {import ('./types/index').URIComponent} relative\n * @param {import('./types/index').Options} [options]\n * @param {boolean} [skipNormalization=false]\n * @returns {import ('./types/index').URIComponent}\n */\nfunction resolveComponent (base, relative, options, skipNormalization) {\n /** @type {import('./types/index').URIComponent} */\n const target = {}\n if (!skipNormalization) {\n base = parse(serialize(base, options), options) // normalize base component\n relative = parse(serialize(relative, options), options) // normalize relative component\n }\n options = options || {}\n\n if (!options.tolerant && relative.scheme) {\n target.scheme = relative.scheme\n // target.authority = relative.authority;\n target.userinfo = relative.userinfo\n target.host = relative.host\n target.port = relative.port\n target.path = removeDotSegments(relative.path || '')\n target.query = relative.query\n } else {\n if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n // target.authority = relative.authority;\n target.userinfo = relative.userinfo\n target.host = relative.host\n target.port = relative.port\n target.path = removeDotSegments(relative.path || '')\n target.query = relative.query\n } else {\n if (!relative.path) {\n target.path = base.path\n if (relative.query !== undefined) {\n target.query = relative.query\n } else {\n target.query = base.query\n }\n } else {\n if (relative.path[0] === '/') {\n target.path = removeDotSegments(relative.path)\n } else {\n if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n target.path = '/' + relative.path\n } else if (!base.path) {\n target.path = relative.path\n } else {\n target.path = base.path.slice(0, base.path.lastIndexOf('/') + 1) + relative.path\n }\n target.path = removeDotSegments(target.path)\n }\n target.query = relative.query\n }\n // target.authority = base.authority;\n target.userinfo = base.userinfo\n target.host = base.host\n target.port = base.port\n }\n target.scheme = base.scheme\n }\n\n target.fragment = relative.fragment\n\n return target\n}\n\n/**\n * @param {import ('./types/index').URIComponent|string} uriA\n * @param {import ('./types/index').URIComponent|string} uriB\n * @param {import ('./types/index').Options} options\n * @returns {boolean}\n */\nfunction equal (uriA, uriB, options) {\n if (typeof uriA === 'string') {\n uriA = unescape(uriA)\n uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), { ...options, skipEscape: true })\n } else if (typeof uriA === 'object') {\n uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true })\n }\n\n if (typeof uriB === 'string') {\n uriB = unescape(uriB)\n uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), { ...options, skipEscape: true })\n } else if (typeof uriB === 'object') {\n uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true })\n }\n\n return uriA.toLowerCase() === uriB.toLowerCase()\n}\n\n/**\n * @param {Readonly} cmpts\n * @param {import('./types/index').Options} [opts]\n * @returns {string}\n */\nfunction serialize (cmpts, opts) {\n const component = {\n host: cmpts.host,\n scheme: cmpts.scheme,\n userinfo: cmpts.userinfo,\n port: cmpts.port,\n path: cmpts.path,\n query: cmpts.query,\n nid: cmpts.nid,\n nss: cmpts.nss,\n uuid: cmpts.uuid,\n fragment: cmpts.fragment,\n reference: cmpts.reference,\n resourceName: cmpts.resourceName,\n secure: cmpts.secure,\n error: ''\n }\n const options = Object.assign({}, opts)\n const uriTokens = []\n\n // find scheme handler\n const schemeHandler = getSchemeHandler(options.scheme || component.scheme)\n\n // perform scheme specific serialization\n if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options)\n\n if (component.path !== undefined) {\n if (!options.skipEscape) {\n component.path = escape(component.path)\n\n if (component.scheme !== undefined) {\n component.path = component.path.split('%3A').join(':')\n }\n } else {\n component.path = unescape(component.path)\n }\n }\n\n if (options.reference !== 'suffix' && component.scheme) {\n uriTokens.push(component.scheme, ':')\n }\n\n const authority = recomposeAuthority(component)\n if (authority !== undefined) {\n if (options.reference !== 'suffix') {\n uriTokens.push('//')\n }\n\n uriTokens.push(authority)\n\n if (component.path && component.path[0] !== '/') {\n uriTokens.push('/')\n }\n }\n if (component.path !== undefined) {\n let s = component.path\n\n if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n s = removeDotSegments(s)\n }\n\n if (\n authority === undefined &&\n s[0] === '/' &&\n s[1] === '/'\n ) {\n // don't allow the path to start with \"//\"\n s = '/%2F' + s.slice(2)\n }\n\n uriTokens.push(s)\n }\n\n if (component.query !== undefined) {\n uriTokens.push('?', component.query)\n }\n\n if (component.fragment !== undefined) {\n uriTokens.push('#', component.fragment)\n }\n return uriTokens.join('')\n}\n\nconst URI_PARSE = /^(?:([^#/:?]+):)?(?:\\/\\/((?:([^#/?@]*)@)?(\\[[^#/?\\]]+\\]|[^#/:?]*)(?::(\\d*))?))?([^#?]*)(?:\\?([^#]*))?(?:#((?:.|[\\n\\r])*))?/u\n\n/**\n * @param {string} uri\n * @param {import('./types/index').Options} [opts]\n * @returns\n */\nfunction parse (uri, opts) {\n const options = Object.assign({}, opts)\n /** @type {import('./types/index').URIComponent} */\n const parsed = {\n scheme: undefined,\n userinfo: undefined,\n host: '',\n port: undefined,\n path: '',\n query: undefined,\n fragment: undefined\n }\n\n let isIP = false\n if (options.reference === 'suffix') {\n if (options.scheme) {\n uri = options.scheme + ':' + uri\n } else {\n uri = '//' + uri\n }\n }\n\n const matches = uri.match(URI_PARSE)\n\n if (matches) {\n // store each component\n parsed.scheme = matches[1]\n parsed.userinfo = matches[3]\n parsed.host = matches[4]\n parsed.port = parseInt(matches[5], 10)\n parsed.path = matches[6] || ''\n parsed.query = matches[7]\n parsed.fragment = matches[8]\n\n // fix port number\n if (isNaN(parsed.port)) {\n parsed.port = matches[5]\n }\n if (parsed.host) {\n const ipv4result = isIPv4(parsed.host)\n if (ipv4result === false) {\n const ipv6result = normalizeIPv6(parsed.host)\n parsed.host = ipv6result.host.toLowerCase()\n isIP = ipv6result.isIPV6\n } else {\n isIP = true\n }\n }\n if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) {\n parsed.reference = 'same-document'\n } else if (parsed.scheme === undefined) {\n parsed.reference = 'relative'\n } else if (parsed.fragment === undefined) {\n parsed.reference = 'absolute'\n } else {\n parsed.reference = 'uri'\n }\n\n // check for reference errors\n if (options.reference && options.reference !== 'suffix' && options.reference !== parsed.reference) {\n parsed.error = parsed.error || 'URI is not a ' + options.reference + ' reference.'\n }\n\n // find scheme handler\n const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme)\n\n // check if scheme can't handle IRIs\n if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n // if host component is a domain name\n if (parsed.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost)) && isIP === false && nonSimpleDomain(parsed.host)) {\n // convert Unicode IDN -> ASCII IDN\n try {\n parsed.host = URL.domainToASCII(parsed.host.toLowerCase())\n } catch (e) {\n parsed.error = parsed.error || \"Host's domain name can not be converted to ASCII: \" + e\n }\n }\n // convert IRI -> URI\n }\n\n if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {\n if (uri.indexOf('%') !== -1) {\n if (parsed.scheme !== undefined) {\n parsed.scheme = unescape(parsed.scheme)\n }\n if (parsed.host !== undefined) {\n parsed.host = unescape(parsed.host)\n }\n }\n if (parsed.path) {\n parsed.path = escape(unescape(parsed.path))\n }\n if (parsed.fragment) {\n parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment))\n }\n }\n\n // perform scheme specific parsing\n if (schemeHandler && schemeHandler.parse) {\n schemeHandler.parse(parsed, options)\n }\n } else {\n parsed.error = parsed.error || 'URI can not be parsed.'\n }\n return parsed\n}\n\nconst fastUri = {\n SCHEMES,\n normalize,\n resolve,\n resolveComponent,\n equal,\n serialize,\n parse\n}\n\nmodule.exports = fastUri\nmodule.exports.default = fastUri\nmodule.exports.fastUri = fastUri\n", "import * as uri from \"fast-uri\"\n\ntype URI = typeof uri & {code: string}\n;(uri as URI).code = 'require(\"ajv/dist/runtime/uri\").default'\n\nexport default uri as URI\n", "export {\n Format,\n FormatDefinition,\n AsyncFormatDefinition,\n KeywordDefinition,\n KeywordErrorDefinition,\n CodeKeywordDefinition,\n MacroKeywordDefinition,\n FuncKeywordDefinition,\n Vocabulary,\n Schema,\n SchemaObject,\n AnySchemaObject,\n AsyncSchema,\n AnySchema,\n ValidateFunction,\n AsyncValidateFunction,\n AnyValidateFunction,\n ErrorObject,\n ErrorNoParams,\n} from \"./types\"\n\nexport {SchemaCxt, SchemaObjCxt} from \"./compile\"\nexport interface Plugin {\n (ajv: Ajv, options?: Opts): Ajv\n [prop: string]: any\n}\n\nexport {KeywordCxt} from \"./compile/validate\"\nexport {DefinedError} from \"./vocabularies/errors\"\nexport {JSONType} from \"./compile/rules\"\nexport {JSONSchemaType} from \"./types/json-schema\"\nexport {JTDSchemaType, SomeJTDSchemaType, JTDDataType} from \"./types/jtd-schema\"\nexport {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from \"./compile/codegen\"\n\nimport type {\n Schema,\n AnySchema,\n AnySchemaObject,\n SchemaObject,\n AsyncSchema,\n Vocabulary,\n KeywordDefinition,\n AddedKeywordDefinition,\n AnyValidateFunction,\n ValidateFunction,\n AsyncValidateFunction,\n ErrorObject,\n Format,\n AddedFormat,\n RegExpEngine,\n UriResolver,\n} from \"./types\"\nimport type {JSONSchemaType} from \"./types/json-schema\"\nimport type {JTDSchemaType, SomeJTDSchemaType, JTDDataType} from \"./types/jtd-schema\"\nimport ValidationError from \"./runtime/validation_error\"\nimport MissingRefError from \"./compile/ref_error\"\nimport {getRules, ValidationRules, Rule, RuleGroup, JSONType} from \"./compile/rules\"\nimport {SchemaEnv, compileSchema, resolveSchema} from \"./compile\"\nimport {Code, ValueScope} from \"./compile/codegen\"\nimport {normalizeId, getSchemaRefs} from \"./compile/resolve\"\nimport {getJSONTypes} from \"./compile/validate/dataType\"\nimport {eachItem} from \"./compile/util\"\nimport * as $dataRefSchema from \"./refs/data.json\"\n\nimport DefaultUriResolver from \"./runtime/uri\"\n\nconst defaultRegExp: RegExpEngine = (str, flags) => new RegExp(str, flags)\ndefaultRegExp.code = \"new RegExp\"\n\nconst META_IGNORE_OPTIONS: (keyof Options)[] = [\"removeAdditional\", \"useDefaults\", \"coerceTypes\"]\nconst EXT_SCOPE_NAMES = new Set([\n \"validate\",\n \"serialize\",\n \"parse\",\n \"wrapper\",\n \"root\",\n \"schema\",\n \"keyword\",\n \"pattern\",\n \"formats\",\n \"validate$data\",\n \"func\",\n \"obj\",\n \"Error\",\n])\n\nexport type Options = CurrentOptions & DeprecatedOptions\n\nexport interface CurrentOptions {\n // strict mode options (NEW)\n strict?: boolean | \"log\"\n strictSchema?: boolean | \"log\"\n strictNumbers?: boolean | \"log\"\n strictTypes?: boolean | \"log\"\n strictTuples?: boolean | \"log\"\n strictRequired?: boolean | \"log\"\n allowMatchingProperties?: boolean // disables a strict mode restriction\n allowUnionTypes?: boolean\n validateFormats?: boolean\n // validation and reporting options:\n $data?: boolean\n allErrors?: boolean\n verbose?: boolean\n discriminator?: boolean\n unicodeRegExp?: boolean\n timestamp?: \"string\" | \"date\" // JTD only\n parseDate?: boolean // JTD only\n allowDate?: boolean // JTD only\n $comment?:\n | true\n | ((comment: string, schemaPath?: string, rootSchema?: AnySchemaObject) => unknown)\n formats?: {[Name in string]?: Format}\n keywords?: Vocabulary\n schemas?: AnySchema[] | {[Key in string]?: AnySchema}\n logger?: Logger | false\n loadSchema?: (uri: string) => Promise\n // options to modify validated data:\n removeAdditional?: boolean | \"all\" | \"failing\"\n useDefaults?: boolean | \"empty\"\n coerceTypes?: boolean | \"array\"\n // advanced options:\n next?: boolean // NEW\n unevaluated?: boolean // NEW\n dynamicRef?: boolean // NEW\n schemaId?: \"id\" | \"$id\"\n jtd?: boolean // NEW\n meta?: SchemaObject | boolean\n defaultMeta?: string | AnySchemaObject\n validateSchema?: boolean | \"log\"\n addUsedSchema?: boolean\n inlineRefs?: boolean | number\n passContext?: boolean\n loopRequired?: number\n loopEnum?: number // NEW\n ownProperties?: boolean\n multipleOfPrecision?: number\n int32range?: boolean // JTD only\n messages?: boolean\n code?: CodeOptions // NEW\n uriResolver?: UriResolver\n}\n\nexport interface CodeOptions {\n es5?: boolean\n esm?: boolean\n lines?: boolean\n optimize?: boolean | number\n formats?: Code // code to require (or construct) map of available formats - for standalone code\n source?: boolean\n process?: (code: string, schema?: SchemaEnv) => string\n regExp?: RegExpEngine\n}\n\ninterface InstanceCodeOptions extends CodeOptions {\n regExp: RegExpEngine\n optimize: number\n}\n\ninterface DeprecatedOptions {\n /** @deprecated */\n ignoreKeywordsWithRef?: boolean\n /** @deprecated */\n jsPropertySyntax?: boolean // added instead of jsonPointers\n /** @deprecated */\n unicode?: boolean\n}\n\ninterface RemovedOptions {\n format?: boolean\n errorDataPath?: \"object\" | \"property\"\n nullable?: boolean // \"nullable\" keyword is supported by default\n jsonPointers?: boolean\n extendRefs?: true | \"ignore\" | \"fail\"\n missingRefs?: true | \"ignore\" | \"fail\"\n processCode?: (code: string, schema?: SchemaEnv) => string\n sourceCode?: boolean\n strictDefaults?: boolean\n strictKeywords?: boolean\n uniqueItems?: boolean\n unknownFormats?: true | string[] | \"ignore\"\n cache?: any\n serialize?: (schema: AnySchema) => unknown\n ajvErrors?: boolean\n}\n\ntype OptionsInfo = {\n [K in keyof T]-?: string | undefined\n}\n\nconst removedOptions: OptionsInfo = {\n errorDataPath: \"\",\n format: \"`validateFormats: false` can be used instead.\",\n nullable: '\"nullable\" keyword is supported by default.',\n jsonPointers: \"Deprecated jsPropertySyntax can be used instead.\",\n extendRefs: \"Deprecated ignoreKeywordsWithRef can be used instead.\",\n missingRefs: \"Pass empty schema with $id that should be ignored to ajv.addSchema.\",\n processCode: \"Use option `code: {process: (code, schemaEnv: object) => string}`\",\n sourceCode: \"Use option `code: {source: true}`\",\n strictDefaults: \"It is default now, see option `strict`.\",\n strictKeywords: \"It is default now, see option `strict`.\",\n uniqueItems: '\"uniqueItems\" keyword is always validated.',\n unknownFormats: \"Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).\",\n cache: \"Map is used as cache, schema object as key.\",\n serialize: \"Map is used as cache, schema object as key.\",\n ajvErrors: \"It is default now.\",\n}\n\nconst deprecatedOptions: OptionsInfo = {\n ignoreKeywordsWithRef: \"\",\n jsPropertySyntax: \"\",\n unicode: '\"minLength\"/\"maxLength\" account for unicode characters by default.',\n}\n\ntype RequiredInstanceOptions = {\n [K in\n | \"strictSchema\"\n | \"strictNumbers\"\n | \"strictTypes\"\n | \"strictTuples\"\n | \"strictRequired\"\n | \"inlineRefs\"\n | \"loopRequired\"\n | \"loopEnum\"\n | \"meta\"\n | \"messages\"\n | \"schemaId\"\n | \"addUsedSchema\"\n | \"validateSchema\"\n | \"validateFormats\"\n | \"int32range\"\n | \"unicodeRegExp\"\n | \"uriResolver\"]: NonNullable\n} & {code: InstanceCodeOptions}\n\nexport type InstanceOptions = Options & RequiredInstanceOptions\n\nconst MAX_EXPRESSION = 200\n\n// eslint-disable-next-line complexity\nfunction requiredOptions(o: Options): RequiredInstanceOptions {\n const s = o.strict\n const _optz = o.code?.optimize\n const optimize = _optz === true || _optz === undefined ? 1 : _optz || 0\n const regExp = o.code?.regExp ?? defaultRegExp\n const uriResolver = o.uriResolver ?? DefaultUriResolver\n return {\n strictSchema: o.strictSchema ?? s ?? true,\n strictNumbers: o.strictNumbers ?? s ?? true,\n strictTypes: o.strictTypes ?? s ?? \"log\",\n strictTuples: o.strictTuples ?? s ?? \"log\",\n strictRequired: o.strictRequired ?? s ?? false,\n code: o.code ? {...o.code, optimize, regExp} : {optimize, regExp},\n loopRequired: o.loopRequired ?? MAX_EXPRESSION,\n loopEnum: o.loopEnum ?? MAX_EXPRESSION,\n meta: o.meta ?? true,\n messages: o.messages ?? true,\n inlineRefs: o.inlineRefs ?? true,\n schemaId: o.schemaId ?? \"$id\",\n addUsedSchema: o.addUsedSchema ?? true,\n validateSchema: o.validateSchema ?? true,\n validateFormats: o.validateFormats ?? true,\n unicodeRegExp: o.unicodeRegExp ?? true,\n int32range: o.int32range ?? true,\n uriResolver: uriResolver,\n }\n}\n\nexport interface Logger {\n log(...args: unknown[]): unknown\n warn(...args: unknown[]): unknown\n error(...args: unknown[]): unknown\n}\n\nexport default class Ajv {\n opts: InstanceOptions\n errors?: ErrorObject[] | null // errors from the last validation\n logger: Logger\n // shared external scope values for compiled functions\n readonly scope: ValueScope\n readonly schemas: {[Key in string]?: SchemaEnv} = {}\n readonly refs: {[Ref in string]?: SchemaEnv | string} = {}\n readonly formats: {[Name in string]?: AddedFormat} = {}\n readonly RULES: ValidationRules\n readonly _compilations: Set = new Set()\n private readonly _loading: {[Ref in string]?: Promise} = {}\n private readonly _cache: Map = new Map()\n private readonly _metaOpts: InstanceOptions\n\n static ValidationError = ValidationError\n static MissingRefError = MissingRefError\n\n constructor(opts: Options = {}) {\n opts = this.opts = {...opts, ...requiredOptions(opts)}\n const {es5, lines} = this.opts.code\n\n this.scope = new ValueScope({scope: {}, prefixes: EXT_SCOPE_NAMES, es5, lines})\n this.logger = getLogger(opts.logger)\n const formatOpt = opts.validateFormats\n opts.validateFormats = false\n\n this.RULES = getRules()\n checkOptions.call(this, removedOptions, opts, \"NOT SUPPORTED\")\n checkOptions.call(this, deprecatedOptions, opts, \"DEPRECATED\", \"warn\")\n this._metaOpts = getMetaSchemaOptions.call(this)\n\n if (opts.formats) addInitialFormats.call(this)\n this._addVocabularies()\n this._addDefaultMetaSchema()\n if (opts.keywords) addInitialKeywords.call(this, opts.keywords)\n if (typeof opts.meta == \"object\") this.addMetaSchema(opts.meta)\n addInitialSchemas.call(this)\n opts.validateFormats = formatOpt\n }\n\n _addVocabularies(): void {\n this.addKeyword(\"$async\")\n }\n\n _addDefaultMetaSchema(): void {\n const {$data, meta, schemaId} = this.opts\n let _dataRefSchema: SchemaObject = $dataRefSchema\n if (schemaId === \"id\") {\n _dataRefSchema = {...$dataRefSchema}\n _dataRefSchema.id = _dataRefSchema.$id\n delete _dataRefSchema.$id\n }\n if (meta && $data) this.addMetaSchema(_dataRefSchema, _dataRefSchema[schemaId], false)\n }\n\n defaultMeta(): string | AnySchemaObject | undefined {\n const {meta, schemaId} = this.opts\n return (this.opts.defaultMeta = typeof meta == \"object\" ? meta[schemaId] || meta : undefined)\n }\n\n // Validate data using schema\n // AnySchema will be compiled and cached using schema itself as a key for Map\n validate(schema: Schema | string, data: unknown): boolean\n validate(schemaKeyRef: AnySchema | string, data: unknown): boolean | Promise\n validate(schema: Schema | JSONSchemaType | string, data: unknown): data is T\n // Separated for type inference to work\n // eslint-disable-next-line @typescript-eslint/unified-signatures\n validate(schema: JTDSchemaType, data: unknown): data is T\n // This overload is only intended for typescript inference, the first\n // argument prevents manual type annotation from matching this overload\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n validate(\n schema: T,\n data: unknown\n ): data is JTDDataType\n // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\n validate(schema: AsyncSchema, data: unknown | T): Promise\n validate(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise\n validate(\n schemaKeyRef: AnySchema | string, // key, ref or schema object\n // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents\n data: unknown | T // to be validated\n ): boolean | Promise {\n let v: AnyValidateFunction | undefined\n if (typeof schemaKeyRef == \"string\") {\n v = this.getSchema(schemaKeyRef)\n if (!v) throw new Error(`no schema with key or ref \"${schemaKeyRef}\"`)\n } else {\n v = this.compile(schemaKeyRef)\n }\n\n const valid = v(data)\n if (!(\"$async\" in v)) this.errors = v.errors\n return valid\n }\n\n // Create validation function for passed schema\n // _meta: true if schema is a meta-schema. Used internally to compile meta schemas of user-defined keywords.\n compile(schema: Schema | JSONSchemaType, _meta?: boolean): ValidateFunction\n // Separated for type inference to work\n // eslint-disable-next-line @typescript-eslint/unified-signatures\n compile(schema: JTDSchemaType, _meta?: boolean): ValidateFunction\n // This overload is only intended for typescript inference, the first\n // argument prevents manual type annotation from matching this overload\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n compile(\n schema: T,\n _meta?: boolean\n ): ValidateFunction>\n compile(schema: AsyncSchema, _meta?: boolean): AsyncValidateFunction\n compile(schema: AnySchema, _meta?: boolean): AnyValidateFunction\n compile(schema: AnySchema, _meta?: boolean): AnyValidateFunction {\n const sch = this._addSchema(schema, _meta)\n return (sch.validate || this._compileSchemaEnv(sch)) as AnyValidateFunction\n }\n\n // Creates validating function for passed schema with asynchronous loading of missing schemas.\n // `loadSchema` option should be a function that accepts schema uri and returns promise that resolves with the schema.\n // TODO allow passing schema URI\n // meta - optional true to compile meta-schema\n compileAsync(\n schema: SchemaObject | JSONSchemaType,\n _meta?: boolean\n ): Promise>\n // Separated for type inference to work\n // eslint-disable-next-line @typescript-eslint/unified-signatures\n compileAsync(schema: JTDSchemaType, _meta?: boolean): Promise>\n compileAsync(schema: AsyncSchema, meta?: boolean): Promise>\n // eslint-disable-next-line @typescript-eslint/unified-signatures\n compileAsync(\n schema: AnySchemaObject,\n meta?: boolean\n ): Promise>\n compileAsync(\n schema: AnySchemaObject,\n meta?: boolean\n ): Promise> {\n if (typeof this.opts.loadSchema != \"function\") {\n throw new Error(\"options.loadSchema should be a function\")\n }\n const {loadSchema} = this.opts\n return runCompileAsync.call(this, schema, meta)\n\n async function runCompileAsync(\n this: Ajv,\n _schema: AnySchemaObject,\n _meta?: boolean\n ): Promise {\n await loadMetaSchema.call(this, _schema.$schema)\n const sch = this._addSchema(_schema, _meta)\n return sch.validate || _compileAsync.call(this, sch)\n }\n\n async function loadMetaSchema(this: Ajv, $ref?: string): Promise {\n if ($ref && !this.getSchema($ref)) {\n await runCompileAsync.call(this, {$ref}, true)\n }\n }\n\n async function _compileAsync(this: Ajv, sch: SchemaEnv): Promise {\n try {\n return this._compileSchemaEnv(sch)\n } catch (e) {\n if (!(e instanceof MissingRefError)) throw e\n checkLoaded.call(this, e)\n await loadMissingSchema.call(this, e.missingSchema)\n return _compileAsync.call(this, sch)\n }\n }\n\n function checkLoaded(this: Ajv, {missingSchema: ref, missingRef}: MissingRefError): void {\n if (this.refs[ref]) {\n throw new Error(`AnySchema ${ref} is loaded but ${missingRef} cannot be resolved`)\n }\n }\n\n async function loadMissingSchema(this: Ajv, ref: string): Promise {\n const _schema = await _loadSchema.call(this, ref)\n if (!this.refs[ref]) await loadMetaSchema.call(this, _schema.$schema)\n if (!this.refs[ref]) this.addSchema(_schema, ref, meta)\n }\n\n async function _loadSchema(this: Ajv, ref: string): Promise {\n const p = this._loading[ref]\n if (p) return p\n try {\n return await (this._loading[ref] = loadSchema(ref))\n } finally {\n delete this._loading[ref]\n }\n }\n }\n\n // Adds schema to the instance\n addSchema(\n schema: AnySchema | AnySchema[], // If array is passed, `key` will be ignored\n key?: string, // Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.\n _meta?: boolean, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.\n _validateSchema = this.opts.validateSchema // false to skip schema validation. Used internally, option validateSchema should be used instead.\n ): Ajv {\n if (Array.isArray(schema)) {\n for (const sch of schema) this.addSchema(sch, undefined, _meta, _validateSchema)\n return this\n }\n let id: string | undefined\n if (typeof schema === \"object\") {\n const {schemaId} = this.opts\n id = schema[schemaId]\n if (id !== undefined && typeof id != \"string\") {\n throw new Error(`schema ${schemaId} must be string`)\n }\n }\n key = normalizeId(key || id)\n this._checkUnique(key)\n this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true)\n return this\n }\n\n // Add schema that will be used to validate other schemas\n // options in META_IGNORE_OPTIONS are alway set to false\n addMetaSchema(\n schema: AnySchemaObject,\n key?: string, // schema key\n _validateSchema = this.opts.validateSchema // false to skip schema validation, can be used to override validateSchema option for meta-schema\n ): Ajv {\n this.addSchema(schema, key, true, _validateSchema)\n return this\n }\n\n // Validate schema against its meta-schema\n validateSchema(schema: AnySchema, throwOrLogError?: boolean): boolean | Promise {\n if (typeof schema == \"boolean\") return true\n let $schema: string | AnySchemaObject | undefined\n $schema = schema.$schema\n if ($schema !== undefined && typeof $schema != \"string\") {\n throw new Error(\"$schema must be a string\")\n }\n $schema = $schema || this.opts.defaultMeta || this.defaultMeta()\n if (!$schema) {\n this.logger.warn(\"meta-schema not available\")\n this.errors = null\n return true\n }\n const valid = this.validate($schema, schema)\n if (!valid && throwOrLogError) {\n const message = \"schema is invalid: \" + this.errorsText()\n if (this.opts.validateSchema === \"log\") this.logger.error(message)\n else throw new Error(message)\n }\n return valid\n }\n\n // Get compiled schema by `key` or `ref`.\n // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)\n getSchema(keyRef: string): AnyValidateFunction | undefined {\n let sch\n while (typeof (sch = getSchEnv.call(this, keyRef)) == \"string\") keyRef = sch\n if (sch === undefined) {\n const {schemaId} = this.opts\n const root = new SchemaEnv({schema: {}, schemaId})\n sch = resolveSchema.call(this, root, keyRef)\n if (!sch) return\n this.refs[keyRef] = sch\n }\n return (sch.validate || this._compileSchemaEnv(sch)) as AnyValidateFunction | undefined\n }\n\n // Remove cached schema(s).\n // If no parameter is passed all schemas but meta-schemas are removed.\n // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.\n // Even if schema is referenced by other schemas it still can be removed as other schemas have local references.\n removeSchema(schemaKeyRef?: AnySchema | string | RegExp): Ajv {\n if (schemaKeyRef instanceof RegExp) {\n this._removeAllSchemas(this.schemas, schemaKeyRef)\n this._removeAllSchemas(this.refs, schemaKeyRef)\n return this\n }\n switch (typeof schemaKeyRef) {\n case \"undefined\":\n this._removeAllSchemas(this.schemas)\n this._removeAllSchemas(this.refs)\n this._cache.clear()\n return this\n case \"string\": {\n const sch = getSchEnv.call(this, schemaKeyRef)\n if (typeof sch == \"object\") this._cache.delete(sch.schema)\n delete this.schemas[schemaKeyRef]\n delete this.refs[schemaKeyRef]\n return this\n }\n case \"object\": {\n const cacheKey = schemaKeyRef\n this._cache.delete(cacheKey)\n let id = schemaKeyRef[this.opts.schemaId]\n if (id) {\n id = normalizeId(id)\n delete this.schemas[id]\n delete this.refs[id]\n }\n return this\n }\n default:\n throw new Error(\"ajv.removeSchema: invalid parameter\")\n }\n }\n\n // add \"vocabulary\" - a collection of keywords\n addVocabulary(definitions: Vocabulary): Ajv {\n for (const def of definitions) this.addKeyword(def)\n return this\n }\n\n addKeyword(\n kwdOrDef: string | KeywordDefinition,\n def?: KeywordDefinition // deprecated\n ): Ajv {\n let keyword: string | string[]\n if (typeof kwdOrDef == \"string\") {\n keyword = kwdOrDef\n if (typeof def == \"object\") {\n this.logger.warn(\"these parameters are deprecated, see docs for addKeyword\")\n def.keyword = keyword\n }\n } else if (typeof kwdOrDef == \"object\" && def === undefined) {\n def = kwdOrDef\n keyword = def.keyword\n if (Array.isArray(keyword) && !keyword.length) {\n throw new Error(\"addKeywords: keyword must be string or non-empty array\")\n }\n } else {\n throw new Error(\"invalid addKeywords parameters\")\n }\n\n checkKeyword.call(this, keyword, def)\n if (!def) {\n eachItem(keyword, (kwd) => addRule.call(this, kwd))\n return this\n }\n keywordMetaschema.call(this, def)\n const definition: AddedKeywordDefinition = {\n ...def,\n type: getJSONTypes(def.type),\n schemaType: getJSONTypes(def.schemaType),\n }\n eachItem(\n keyword,\n definition.type.length === 0\n ? (k) => addRule.call(this, k, definition)\n : (k) => definition.type.forEach((t) => addRule.call(this, k, definition, t))\n )\n return this\n }\n\n getKeyword(keyword: string): AddedKeywordDefinition | boolean {\n const rule = this.RULES.all[keyword]\n return typeof rule == \"object\" ? rule.definition : !!rule\n }\n\n // Remove keyword\n removeKeyword(keyword: string): Ajv {\n // TODO return type should be Ajv\n const {RULES} = this\n delete RULES.keywords[keyword]\n delete RULES.all[keyword]\n for (const group of RULES.rules) {\n const i = group.rules.findIndex((rule) => rule.keyword === keyword)\n if (i >= 0) group.rules.splice(i, 1)\n }\n return this\n }\n\n // Add format\n addFormat(name: string, format: Format): Ajv {\n if (typeof format == \"string\") format = new RegExp(format)\n this.formats[name] = format\n return this\n }\n\n errorsText(\n errors: ErrorObject[] | null | undefined = this.errors, // optional array of validation errors\n {separator = \", \", dataVar = \"data\"}: ErrorsTextOptions = {} // optional options with properties `separator` and `dataVar`\n ): string {\n if (!errors || errors.length === 0) return \"No errors\"\n return errors\n .map((e) => `${dataVar}${e.instancePath} ${e.message}`)\n .reduce((text, msg) => text + separator + msg)\n }\n\n $dataMetaSchema(metaSchema: AnySchemaObject, keywordsJsonPointers: string[]): AnySchemaObject {\n const rules = this.RULES.all\n metaSchema = JSON.parse(JSON.stringify(metaSchema))\n for (const jsonPointer of keywordsJsonPointers) {\n const segments = jsonPointer.split(\"/\").slice(1) // first segment is an empty string\n let keywords = metaSchema\n for (const seg of segments) keywords = keywords[seg] as AnySchemaObject\n\n for (const key in rules) {\n const rule = rules[key]\n if (typeof rule != \"object\") continue\n const {$data} = rule.definition\n const schema = keywords[key] as AnySchemaObject | undefined\n if ($data && schema) keywords[key] = schemaOrData(schema)\n }\n }\n\n return metaSchema\n }\n\n private _removeAllSchemas(schemas: {[Ref in string]?: SchemaEnv | string}, regex?: RegExp): void {\n for (const keyRef in schemas) {\n const sch = schemas[keyRef]\n if (!regex || regex.test(keyRef)) {\n if (typeof sch == \"string\") {\n delete schemas[keyRef]\n } else if (sch && !sch.meta) {\n this._cache.delete(sch.schema)\n delete schemas[keyRef]\n }\n }\n }\n }\n\n _addSchema(\n schema: AnySchema,\n meta?: boolean,\n baseId?: string,\n validateSchema = this.opts.validateSchema,\n addSchema = this.opts.addUsedSchema\n ): SchemaEnv {\n let id: string | undefined\n const {schemaId} = this.opts\n if (typeof schema == \"object\") {\n id = schema[schemaId]\n } else {\n if (this.opts.jtd) throw new Error(\"schema must be object\")\n else if (typeof schema != \"boolean\") throw new Error(\"schema must be object or boolean\")\n }\n let sch = this._cache.get(schema)\n if (sch !== undefined) return sch\n\n baseId = normalizeId(id || baseId)\n const localRefs = getSchemaRefs.call(this, schema, baseId)\n sch = new SchemaEnv({schema, schemaId, meta, baseId, localRefs})\n this._cache.set(sch.schema, sch)\n if (addSchema && !baseId.startsWith(\"#\")) {\n // TODO atm it is allowed to overwrite schemas without id (instead of not adding them)\n if (baseId) this._checkUnique(baseId)\n this.refs[baseId] = sch\n }\n if (validateSchema) this.validateSchema(schema, true)\n return sch\n }\n\n private _checkUnique(id: string): void {\n if (this.schemas[id] || this.refs[id]) {\n throw new Error(`schema with key or id \"${id}\" already exists`)\n }\n }\n\n private _compileSchemaEnv(sch: SchemaEnv): AnyValidateFunction {\n if (sch.meta) this._compileMetaSchema(sch)\n else compileSchema.call(this, sch)\n\n /* istanbul ignore if */\n if (!sch.validate) throw new Error(\"ajv implementation error\")\n return sch.validate\n }\n\n private _compileMetaSchema(sch: SchemaEnv): void {\n const currentOpts = this.opts\n this.opts = this._metaOpts\n try {\n compileSchema.call(this, sch)\n } finally {\n this.opts = currentOpts\n }\n }\n}\n\nexport interface ErrorsTextOptions {\n separator?: string\n dataVar?: string\n}\n\nfunction checkOptions(\n this: Ajv,\n checkOpts: OptionsInfo,\n options: Options & RemovedOptions,\n msg: string,\n log: \"warn\" | \"error\" = \"error\"\n): void {\n for (const key in checkOpts) {\n const opt = key as keyof typeof checkOpts\n if (opt in options) this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`)\n }\n}\n\nfunction getSchEnv(this: Ajv, keyRef: string): SchemaEnv | string | undefined {\n keyRef = normalizeId(keyRef) // TODO tests fail without this line\n return this.schemas[keyRef] || this.refs[keyRef]\n}\n\nfunction addInitialSchemas(this: Ajv): void {\n const optsSchemas = this.opts.schemas\n if (!optsSchemas) return\n if (Array.isArray(optsSchemas)) this.addSchema(optsSchemas)\n else for (const key in optsSchemas) this.addSchema(optsSchemas[key] as AnySchema, key)\n}\n\nfunction addInitialFormats(this: Ajv): void {\n for (const name in this.opts.formats) {\n const format = this.opts.formats[name]\n if (format) this.addFormat(name, format)\n }\n}\n\nfunction addInitialKeywords(\n this: Ajv,\n defs: Vocabulary | {[K in string]?: KeywordDefinition}\n): void {\n if (Array.isArray(defs)) {\n this.addVocabulary(defs)\n return\n }\n this.logger.warn(\"keywords option as map is deprecated, pass array\")\n for (const keyword in defs) {\n const def = defs[keyword] as KeywordDefinition\n if (!def.keyword) def.keyword = keyword\n this.addKeyword(def)\n }\n}\n\nfunction getMetaSchemaOptions(this: Ajv): InstanceOptions {\n const metaOpts = {...this.opts}\n for (const opt of META_IGNORE_OPTIONS) delete metaOpts[opt]\n return metaOpts\n}\n\nconst noLogs = {log() {}, warn() {}, error() {}}\n\nfunction getLogger(logger?: Partial | false): Logger {\n if (logger === false) return noLogs\n if (logger === undefined) return console\n if (logger.log && logger.warn && logger.error) return logger as Logger\n throw new Error(\"logger must implement log, warn and error methods\")\n}\n\nconst KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i\n\nfunction checkKeyword(this: Ajv, keyword: string | string[], def?: KeywordDefinition): void {\n const {RULES} = this\n eachItem(keyword, (kwd) => {\n if (RULES.keywords[kwd]) throw new Error(`Keyword ${kwd} is already defined`)\n if (!KEYWORD_NAME.test(kwd)) throw new Error(`Keyword ${kwd} has invalid name`)\n })\n if (!def) return\n if (def.$data && !(\"code\" in def || \"validate\" in def)) {\n throw new Error('$data keyword must have \"code\" or \"validate\" function')\n }\n}\n\nfunction addRule(\n this: Ajv,\n keyword: string,\n definition?: AddedKeywordDefinition,\n dataType?: JSONType\n): void {\n const post = definition?.post\n if (dataType && post) throw new Error('keyword with \"post\" flag cannot have \"type\"')\n const {RULES} = this\n let ruleGroup = post ? RULES.post : RULES.rules.find(({type: t}) => t === dataType)\n if (!ruleGroup) {\n ruleGroup = {type: dataType, rules: []}\n RULES.rules.push(ruleGroup)\n }\n RULES.keywords[keyword] = true\n if (!definition) return\n\n const rule: Rule = {\n keyword,\n definition: {\n ...definition,\n type: getJSONTypes(definition.type),\n schemaType: getJSONTypes(definition.schemaType),\n },\n }\n if (definition.before) addBeforeRule.call(this, ruleGroup, rule, definition.before)\n else ruleGroup.rules.push(rule)\n RULES.all[keyword] = rule\n definition.implements?.forEach((kwd) => this.addKeyword(kwd))\n}\n\nfunction addBeforeRule(this: Ajv, ruleGroup: RuleGroup, rule: Rule, before: string): void {\n const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before)\n if (i >= 0) {\n ruleGroup.rules.splice(i, 0, rule)\n } else {\n ruleGroup.rules.push(rule)\n this.logger.warn(`rule ${before} is not defined`)\n }\n}\n\nfunction keywordMetaschema(this: Ajv, def: KeywordDefinition): void {\n let {metaSchema} = def\n if (metaSchema === undefined) return\n if (def.$data && this.opts.$data) metaSchema = schemaOrData(metaSchema)\n def.validateSchema = this.compile(metaSchema, true)\n}\n\nconst $dataRef = {\n $ref: \"https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#\",\n}\n\nfunction schemaOrData(schema: AnySchema): AnySchemaObject {\n return {anyOf: [schema, $dataRef]}\n}\n", "import type {CodeKeywordDefinition} from \"../../types\"\n\nconst def: CodeKeywordDefinition = {\n keyword: \"id\",\n code() {\n throw new Error('NOT SUPPORTED: keyword \"id\", use \"$id\" for schema ID')\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, AnySchema} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport MissingRefError from \"../../compile/ref_error\"\nimport {callValidateCode} from \"../code\"\nimport {_, nil, stringify, Code, Name} from \"../../compile/codegen\"\nimport N from \"../../compile/names\"\nimport {SchemaEnv, resolveRef} from \"../../compile\"\nimport {mergeEvaluated} from \"../../compile/util\"\n\nconst def: CodeKeywordDefinition = {\n keyword: \"$ref\",\n schemaType: \"string\",\n code(cxt: KeywordCxt): void {\n const {gen, schema: $ref, it} = cxt\n const {baseId, schemaEnv: env, validateName, opts, self} = it\n const {root} = env\n if (($ref === \"#\" || $ref === \"#/\") && baseId === root.baseId) return callRootRef()\n const schOrEnv = resolveRef.call(self, root, baseId, $ref)\n if (schOrEnv === undefined) throw new MissingRefError(it.opts.uriResolver, baseId, $ref)\n if (schOrEnv instanceof SchemaEnv) return callValidate(schOrEnv)\n return inlineRefSchema(schOrEnv)\n\n function callRootRef(): void {\n if (env === root) return callRef(cxt, validateName, env, env.$async)\n const rootName = gen.scopeValue(\"root\", {ref: root})\n return callRef(cxt, _`${rootName}.validate`, root, root.$async)\n }\n\n function callValidate(sch: SchemaEnv): void {\n const v = getValidate(cxt, sch)\n callRef(cxt, v, sch, sch.$async)\n }\n\n function inlineRefSchema(sch: AnySchema): void {\n const schName = gen.scopeValue(\n \"schema\",\n opts.code.source === true ? {ref: sch, code: stringify(sch)} : {ref: sch}\n )\n const valid = gen.name(\"valid\")\n const schCxt = cxt.subschema(\n {\n schema: sch,\n dataTypes: [],\n schemaPath: nil,\n topSchemaRef: schName,\n errSchemaPath: $ref,\n },\n valid\n )\n cxt.mergeEvaluated(schCxt)\n cxt.ok(valid)\n }\n },\n}\n\nexport function getValidate(cxt: KeywordCxt, sch: SchemaEnv): Code {\n const {gen} = cxt\n return sch.validate\n ? gen.scopeValue(\"validate\", {ref: sch.validate})\n : _`${gen.scopeValue(\"wrapper\", {ref: sch})}.validate`\n}\n\nexport function callRef(cxt: KeywordCxt, v: Code, sch?: SchemaEnv, $async?: boolean): void {\n const {gen, it} = cxt\n const {allErrors, schemaEnv: env, opts} = it\n const passCxt = opts.passContext ? N.this : nil\n if ($async) callAsyncRef()\n else callSyncRef()\n\n function callAsyncRef(): void {\n if (!env.$async) throw new Error(\"async schema referenced by sync schema\")\n const valid = gen.let(\"valid\")\n gen.try(\n () => {\n gen.code(_`await ${callValidateCode(cxt, v, passCxt)}`)\n addEvaluatedFrom(v) // TODO will not work with async, it has to be returned with the result\n if (!allErrors) gen.assign(valid, true)\n },\n (e) => {\n gen.if(_`!(${e} instanceof ${it.ValidationError as Name})`, () => gen.throw(e))\n addErrorsFrom(e)\n if (!allErrors) gen.assign(valid, false)\n }\n )\n cxt.ok(valid)\n }\n\n function callSyncRef(): void {\n cxt.result(\n callValidateCode(cxt, v, passCxt),\n () => addEvaluatedFrom(v),\n () => addErrorsFrom(v)\n )\n }\n\n function addErrorsFrom(source: Code): void {\n const errs = _`${source}.errors`\n gen.assign(N.vErrors, _`${N.vErrors} === null ? ${errs} : ${N.vErrors}.concat(${errs})`) // TODO tagged\n gen.assign(N.errors, _`${N.vErrors}.length`)\n }\n\n function addEvaluatedFrom(source: Code): void {\n if (!it.opts.unevaluated) return\n const schEvaluated = sch?.validate?.evaluated\n // TODO refactor\n if (it.props !== true) {\n if (schEvaluated && !schEvaluated.dynamicProps) {\n if (schEvaluated.props !== undefined) {\n it.props = mergeEvaluated.props(gen, schEvaluated.props, it.props)\n }\n } else {\n const props = gen.var(\"props\", _`${source}.evaluated.props`)\n it.props = mergeEvaluated.props(gen, props, it.props, Name)\n }\n }\n if (it.items !== true) {\n if (schEvaluated && !schEvaluated.dynamicItems) {\n if (schEvaluated.items !== undefined) {\n it.items = mergeEvaluated.items(gen, schEvaluated.items, it.items)\n }\n } else {\n const items = gen.var(\"items\", _`${source}.evaluated.items`)\n it.items = mergeEvaluated.items(gen, items, it.items, Name)\n }\n }\n }\n}\n\nexport default def\n", "import type {Vocabulary} from \"../../types\"\nimport idKeyword from \"./id\"\nimport refKeyword from \"./ref\"\n\nconst core: Vocabulary = [\n \"$schema\",\n \"$id\",\n \"$defs\",\n \"$vocabulary\",\n {keyword: \"$comment\"},\n \"definitions\",\n idKeyword,\n refKeyword,\n]\n\nexport default core\n", "import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, operators, Code} from \"../../compile/codegen\"\n\nconst ops = operators\n\ntype Kwd = \"maximum\" | \"minimum\" | \"exclusiveMaximum\" | \"exclusiveMinimum\"\n\ntype Comparison = \"<=\" | \">=\" | \"<\" | \">\"\n\nconst KWDs: {[K in Kwd]: {okStr: Comparison; ok: Code; fail: Code}} = {\n maximum: {okStr: \"<=\", ok: ops.LTE, fail: ops.GT},\n minimum: {okStr: \">=\", ok: ops.GTE, fail: ops.LT},\n exclusiveMaximum: {okStr: \"<\", ok: ops.LT, fail: ops.GTE},\n exclusiveMinimum: {okStr: \">\", ok: ops.GT, fail: ops.LTE},\n}\n\nexport type LimitNumberError = ErrorObject<\n Kwd,\n {limit: number; comparison: Comparison},\n number | {$data: string}\n>\n\nconst error: KeywordErrorDefinition = {\n message: ({keyword, schemaCode}) => str`must be ${KWDs[keyword as Kwd].okStr} ${schemaCode}`,\n params: ({keyword, schemaCode}) =>\n _`{comparison: ${KWDs[keyword as Kwd].okStr}, limit: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: Object.keys(KWDs),\n type: \"number\",\n schemaType: \"number\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {keyword, data, schemaCode} = cxt\n cxt.fail$data(_`${data} ${KWDs[keyword as Kwd].fail} ${schemaCode} || isNaN(${data})`)\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str} from \"../../compile/codegen\"\n\nexport type MultipleOfError = ErrorObject<\n \"multipleOf\",\n {multipleOf: number},\n number | {$data: string}\n>\n\nconst error: KeywordErrorDefinition = {\n message: ({schemaCode}) => str`must be multiple of ${schemaCode}`,\n params: ({schemaCode}) => _`{multipleOf: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"multipleOf\",\n type: \"number\",\n schemaType: \"number\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, data, schemaCode, it} = cxt\n // const bdt = bad$DataType(schemaCode, def.schemaType, $data)\n const prec = it.opts.multipleOfPrecision\n const res = gen.let(\"res\")\n const invalid = prec\n ? _`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}`\n : _`${res} !== parseInt(${res})`\n cxt.fail$data(_`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`)\n },\n}\n\nexport default def\n", "// https://mathiasbynens.be/notes/javascript-encoding\n// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode\nexport default function ucs2length(str: string): number {\n const len = str.length\n let length = 0\n let pos = 0\n let value: number\n while (pos < len) {\n length++\n value = str.charCodeAt(pos++)\n if (value >= 0xd800 && value <= 0xdbff && pos < len) {\n // high surrogate, and there is a next character\n value = str.charCodeAt(pos)\n if ((value & 0xfc00) === 0xdc00) pos++ // low surrogate\n }\n }\n return length\n}\n\nucs2length.code = 'require(\"ajv/dist/runtime/ucs2length\").default'\n", "import type {CodeKeywordDefinition, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, operators} from \"../../compile/codegen\"\nimport {useFunc} from \"../../compile/util\"\nimport ucs2length from \"../../runtime/ucs2length\"\n\nconst error: KeywordErrorDefinition = {\n message({keyword, schemaCode}) {\n const comp = keyword === \"maxLength\" ? \"more\" : \"fewer\"\n return str`must NOT have ${comp} than ${schemaCode} characters`\n },\n params: ({schemaCode}) => _`{limit: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: [\"maxLength\", \"minLength\"],\n type: \"string\",\n schemaType: \"number\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {keyword, data, schemaCode, it} = cxt\n const op = keyword === \"maxLength\" ? operators.GT : operators.LT\n const len =\n it.opts.unicode === false ? _`${data}.length` : _`${useFunc(cxt.gen, ucs2length)}(${data})`\n cxt.fail$data(_`${len} ${op} ${schemaCode}`)\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {usePattern} from \"../code\"\nimport {_, str} from \"../../compile/codegen\"\n\nexport type PatternError = ErrorObject<\"pattern\", {pattern: string}, string | {$data: string}>\n\nconst error: KeywordErrorDefinition = {\n message: ({schemaCode}) => str`must match pattern \"${schemaCode}\"`,\n params: ({schemaCode}) => _`{pattern: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"pattern\",\n type: \"string\",\n schemaType: \"string\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {data, $data, schema, schemaCode, it} = cxt\n // TODO regexp should be wrapped in try/catchs\n const u = it.opts.unicodeRegExp ? \"u\" : \"\"\n const regExp = $data ? _`(new RegExp(${schemaCode}, ${u}))` : usePattern(cxt, schema)\n cxt.fail$data(_`!${regExp}.test(${data})`)\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, operators} from \"../../compile/codegen\"\n\nconst error: KeywordErrorDefinition = {\n message({keyword, schemaCode}) {\n const comp = keyword === \"maxProperties\" ? \"more\" : \"fewer\"\n return str`must NOT have ${comp} than ${schemaCode} properties`\n },\n params: ({schemaCode}) => _`{limit: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: [\"maxProperties\", \"minProperties\"],\n type: \"object\",\n schemaType: \"number\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {keyword, data, schemaCode} = cxt\n const op = keyword === \"maxProperties\" ? operators.GT : operators.LT\n cxt.fail$data(_`Object.keys(${data}).length ${op} ${schemaCode}`)\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {\n checkReportMissingProp,\n checkMissingProp,\n reportMissingProp,\n propertyInData,\n noPropertyInData,\n} from \"../code\"\nimport {_, str, nil, not, Name, Code} from \"../../compile/codegen\"\nimport {checkStrictMode} from \"../../compile/util\"\n\nexport type RequiredError = ErrorObject<\n \"required\",\n {missingProperty: string},\n string[] | {$data: string}\n>\n\nconst error: KeywordErrorDefinition = {\n message: ({params: {missingProperty}}) => str`must have required property '${missingProperty}'`,\n params: ({params: {missingProperty}}) => _`{missingProperty: ${missingProperty}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"required\",\n type: \"object\",\n schemaType: \"array\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, schema, schemaCode, data, $data, it} = cxt\n const {opts} = it\n if (!$data && schema.length === 0) return\n const useLoop = schema.length >= opts.loopRequired\n if (it.allErrors) allErrorsMode()\n else exitOnErrorMode()\n\n if (opts.strictRequired) {\n const props = cxt.parentSchema.properties\n const {definedProperties} = cxt.it\n for (const requiredKey of schema) {\n if (props?.[requiredKey] === undefined && !definedProperties.has(requiredKey)) {\n const schemaPath = it.schemaEnv.baseId + it.errSchemaPath\n const msg = `required property \"${requiredKey}\" is not defined at \"${schemaPath}\" (strictRequired)`\n checkStrictMode(it, msg, it.opts.strictRequired)\n }\n }\n }\n\n function allErrorsMode(): void {\n if (useLoop || $data) {\n cxt.block$data(nil, loopAllRequired)\n } else {\n for (const prop of schema) {\n checkReportMissingProp(cxt, prop)\n }\n }\n }\n\n function exitOnErrorMode(): void {\n const missing = gen.let(\"missing\")\n if (useLoop || $data) {\n const valid = gen.let(\"valid\", true)\n cxt.block$data(valid, () => loopUntilMissing(missing, valid))\n cxt.ok(valid)\n } else {\n gen.if(checkMissingProp(cxt, schema, missing))\n reportMissingProp(cxt, missing)\n gen.else()\n }\n }\n\n function loopAllRequired(): void {\n gen.forOf(\"prop\", schemaCode as Code, (prop) => {\n cxt.setParams({missingProperty: prop})\n gen.if(noPropertyInData(gen, data, prop, opts.ownProperties), () => cxt.error())\n })\n }\n\n function loopUntilMissing(missing: Name, valid: Name): void {\n cxt.setParams({missingProperty: missing})\n gen.forOf(\n missing,\n schemaCode as Code,\n () => {\n gen.assign(valid, propertyInData(gen, data, missing, opts.ownProperties))\n gen.if(not(valid), () => {\n cxt.error()\n gen.break()\n })\n },\n nil\n )\n }\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, operators} from \"../../compile/codegen\"\n\nconst error: KeywordErrorDefinition = {\n message({keyword, schemaCode}) {\n const comp = keyword === \"maxItems\" ? \"more\" : \"fewer\"\n return str`must NOT have ${comp} than ${schemaCode} items`\n },\n params: ({schemaCode}) => _`{limit: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: [\"maxItems\", \"minItems\"],\n type: \"array\",\n schemaType: \"number\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {keyword, data, schemaCode} = cxt\n const op = keyword === \"maxItems\" ? operators.GT : operators.LT\n cxt.fail$data(_`${data}.length ${op} ${schemaCode}`)\n },\n}\n\nexport default def\n", "// https://github.com/ajv-validator/ajv/issues/889\nimport * as equal from \"fast-deep-equal\"\n\ntype Equal = typeof equal & {code: string}\n;(equal as Equal).code = 'require(\"ajv/dist/runtime/equal\").default'\n\nexport default equal as Equal\n", "import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {checkDataTypes, getSchemaTypes, DataType} from \"../../compile/validate/dataType\"\nimport {_, str, Name} from \"../../compile/codegen\"\nimport {useFunc} from \"../../compile/util\"\nimport equal from \"../../runtime/equal\"\n\nexport type UniqueItemsError = ErrorObject<\n \"uniqueItems\",\n {i: number; j: number},\n boolean | {$data: string}\n>\n\nconst error: KeywordErrorDefinition = {\n message: ({params: {i, j}}) =>\n str`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,\n params: ({params: {i, j}}) => _`{i: ${i}, j: ${j}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"uniqueItems\",\n type: \"array\",\n schemaType: \"boolean\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, data, $data, schema, parentSchema, schemaCode, it} = cxt\n if (!$data && !schema) return\n const valid = gen.let(\"valid\")\n const itemTypes = parentSchema.items ? getSchemaTypes(parentSchema.items) : []\n cxt.block$data(valid, validateUniqueItems, _`${schemaCode} === false`)\n cxt.ok(valid)\n\n function validateUniqueItems(): void {\n const i = gen.let(\"i\", _`${data}.length`)\n const j = gen.let(\"j\")\n cxt.setParams({i, j})\n gen.assign(valid, true)\n gen.if(_`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j))\n }\n\n function canOptimize(): boolean {\n return itemTypes.length > 0 && !itemTypes.some((t) => t === \"object\" || t === \"array\")\n }\n\n function loopN(i: Name, j: Name): void {\n const item = gen.name(\"item\")\n const wrongType = checkDataTypes(itemTypes, item, it.opts.strictNumbers, DataType.Wrong)\n const indices = gen.const(\"indices\", _`{}`)\n gen.for(_`;${i}--;`, () => {\n gen.let(item, _`${data}[${i}]`)\n gen.if(wrongType, _`continue`)\n if (itemTypes.length > 1) gen.if(_`typeof ${item} == \"string\"`, _`${item} += \"_\"`)\n gen\n .if(_`typeof ${indices}[${item}] == \"number\"`, () => {\n gen.assign(j, _`${indices}[${item}]`)\n cxt.error()\n gen.assign(valid, false).break()\n })\n .code(_`${indices}[${item}] = ${i}`)\n })\n }\n\n function loopN2(i: Name, j: Name): void {\n const eql = useFunc(gen, equal)\n const outer = gen.name(\"outer\")\n gen.label(outer).for(_`;${i}--;`, () =>\n gen.for(_`${j} = ${i}; ${j}--;`, () =>\n gen.if(_`${eql}(${data}[${i}], ${data}[${j}])`, () => {\n cxt.error()\n gen.assign(valid, false).break(outer)\n })\n )\n )\n }\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_} from \"../../compile/codegen\"\nimport {useFunc} from \"../../compile/util\"\nimport equal from \"../../runtime/equal\"\n\nexport type ConstError = ErrorObject<\"const\", {allowedValue: any}>\n\nconst error: KeywordErrorDefinition = {\n message: \"must be equal to constant\",\n params: ({schemaCode}) => _`{allowedValue: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"const\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, data, $data, schemaCode, schema} = cxt\n if ($data || (schema && typeof schema == \"object\")) {\n cxt.fail$data(_`!${useFunc(gen, equal)}(${data}, ${schemaCode})`)\n } else {\n cxt.fail(_`${schema} !== ${data}`)\n }\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, or, Name, Code} from \"../../compile/codegen\"\nimport {useFunc} from \"../../compile/util\"\nimport equal from \"../../runtime/equal\"\n\nexport type EnumError = ErrorObject<\"enum\", {allowedValues: any[]}, any[] | {$data: string}>\n\nconst error: KeywordErrorDefinition = {\n message: \"must be equal to one of the allowed values\",\n params: ({schemaCode}) => _`{allowedValues: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"enum\",\n schemaType: \"array\",\n $data: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, data, $data, schema, schemaCode, it} = cxt\n if (!$data && schema.length === 0) throw new Error(\"enum must have non-empty array\")\n const useLoop = schema.length >= it.opts.loopEnum\n let eql: Name | undefined\n const getEql = (): Name => (eql ??= useFunc(gen, equal))\n\n let valid: Code\n if (useLoop || $data) {\n valid = gen.let(\"valid\")\n cxt.block$data(valid, loopEnum)\n } else {\n /* istanbul ignore if */\n if (!Array.isArray(schema)) throw new Error(\"ajv implementation error\")\n const vSchema = gen.const(\"vSchema\", schemaCode)\n valid = or(...schema.map((_x: unknown, i: number) => equalCode(vSchema, i)))\n }\n cxt.pass(valid)\n\n function loopEnum(): void {\n gen.assign(valid, false)\n gen.forOf(\"v\", schemaCode as Code, (v) =>\n gen.if(_`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break())\n )\n }\n\n function equalCode(vSchema: Name, i: number): Code {\n const sch = schema[i]\n return typeof sch === \"object\" && sch !== null\n ? _`${getEql()}(${data}, ${vSchema}[${i}])`\n : _`${data} === ${sch}`\n }\n },\n}\n\nexport default def\n", "import type {ErrorObject, Vocabulary} from \"../../types\"\nimport limitNumber, {LimitNumberError} from \"./limitNumber\"\nimport multipleOf, {MultipleOfError} from \"./multipleOf\"\nimport limitLength from \"./limitLength\"\nimport pattern, {PatternError} from \"./pattern\"\nimport limitProperties from \"./limitProperties\"\nimport required, {RequiredError} from \"./required\"\nimport limitItems from \"./limitItems\"\nimport uniqueItems, {UniqueItemsError} from \"./uniqueItems\"\nimport constKeyword, {ConstError} from \"./const\"\nimport enumKeyword, {EnumError} from \"./enum\"\n\nconst validation: Vocabulary = [\n // number\n limitNumber,\n multipleOf,\n // string\n limitLength,\n pattern,\n // object\n limitProperties,\n required,\n // array\n limitItems,\n uniqueItems,\n // any\n {keyword: \"type\", schemaType: [\"string\", \"array\"]},\n {keyword: \"nullable\", schemaType: \"boolean\"},\n constKeyword,\n enumKeyword,\n]\n\nexport default validation\n\ntype LimitError = ErrorObject<\n \"maxItems\" | \"minItems\" | \"minProperties\" | \"maxProperties\" | \"minLength\" | \"maxLength\",\n {limit: number},\n number | {$data: string}\n>\n\nexport type ValidationKeywordError =\n | LimitError\n | LimitNumberError\n | MultipleOfError\n | PatternError\n | RequiredError\n | UniqueItemsError\n | ConstError\n | EnumError\n", "import type {\n CodeKeywordDefinition,\n ErrorObject,\n KeywordErrorDefinition,\n AnySchema,\n} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, not, Name} from \"../../compile/codegen\"\nimport {alwaysValidSchema, checkStrictMode, Type} from \"../../compile/util\"\n\nexport type AdditionalItemsError = ErrorObject<\"additionalItems\", {limit: number}, AnySchema>\n\nconst error: KeywordErrorDefinition = {\n message: ({params: {len}}) => str`must NOT have more than ${len} items`,\n params: ({params: {len}}) => _`{limit: ${len}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"additionalItems\" as const,\n type: \"array\",\n schemaType: [\"boolean\", \"object\"],\n before: \"uniqueItems\",\n error,\n code(cxt: KeywordCxt) {\n const {parentSchema, it} = cxt\n const {items} = parentSchema\n if (!Array.isArray(items)) {\n checkStrictMode(it, '\"additionalItems\" is ignored when \"items\" is not an array of schemas')\n return\n }\n validateAdditionalItems(cxt, items)\n },\n}\n\nexport function validateAdditionalItems(cxt: KeywordCxt, items: AnySchema[]): void {\n const {gen, schema, data, keyword, it} = cxt\n it.items = true\n const len = gen.const(\"len\", _`${data}.length`)\n if (schema === false) {\n cxt.setParams({len: items.length})\n cxt.pass(_`${len} <= ${items.length}`)\n } else if (typeof schema == \"object\" && !alwaysValidSchema(it, schema)) {\n const valid = gen.var(\"valid\", _`${len} <= ${items.length}`) // TODO var\n gen.if(not(valid), () => validateItems(valid))\n cxt.ok(valid)\n }\n\n function validateItems(valid: Name): void {\n gen.forRange(\"i\", items.length, len, (i) => {\n cxt.subschema({keyword, dataProp: i, dataPropType: Type.Num}, valid)\n if (!it.allErrors) gen.if(not(valid), () => gen.break())\n })\n }\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, AnySchema, AnySchemaObject} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_} from \"../../compile/codegen\"\nimport {alwaysValidSchema, mergeEvaluated, checkStrictMode} from \"../../compile/util\"\nimport {validateArray} from \"../code\"\n\nconst def: CodeKeywordDefinition = {\n keyword: \"items\",\n type: \"array\",\n schemaType: [\"object\", \"array\", \"boolean\"],\n before: \"uniqueItems\",\n code(cxt: KeywordCxt) {\n const {schema, it} = cxt\n if (Array.isArray(schema)) return validateTuple(cxt, \"additionalItems\", schema)\n it.items = true\n if (alwaysValidSchema(it, schema)) return\n cxt.ok(validateArray(cxt))\n },\n}\n\nexport function validateTuple(\n cxt: KeywordCxt,\n extraItems: string,\n schArr: AnySchema[] = cxt.schema\n): void {\n const {gen, parentSchema, data, keyword, it} = cxt\n checkStrictTuple(parentSchema)\n if (it.opts.unevaluated && schArr.length && it.items !== true) {\n it.items = mergeEvaluated.items(gen, schArr.length, it.items)\n }\n const valid = gen.name(\"valid\")\n const len = gen.const(\"len\", _`${data}.length`)\n schArr.forEach((sch: AnySchema, i: number) => {\n if (alwaysValidSchema(it, sch)) return\n gen.if(_`${len} > ${i}`, () =>\n cxt.subschema(\n {\n keyword,\n schemaProp: i,\n dataProp: i,\n },\n valid\n )\n )\n cxt.ok(valid)\n })\n\n function checkStrictTuple(sch: AnySchemaObject): void {\n const {opts, errSchemaPath} = it\n const l = schArr.length\n const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false)\n if (opts.strictTuples && !fullTuple) {\n const msg = `\"${keyword}\" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path \"${errSchemaPath}\"`\n checkStrictMode(it, msg, opts.strictTuples)\n }\n }\n}\n\nexport default def\n", "import type {CodeKeywordDefinition} from \"../../types\"\nimport {validateTuple} from \"./items\"\n\nconst def: CodeKeywordDefinition = {\n keyword: \"prefixItems\",\n type: \"array\",\n schemaType: [\"array\"],\n before: \"uniqueItems\",\n code: (cxt) => validateTuple(cxt, \"items\"),\n}\n\nexport default def\n", "import type {\n CodeKeywordDefinition,\n KeywordErrorDefinition,\n ErrorObject,\n AnySchema,\n} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str} from \"../../compile/codegen\"\nimport {alwaysValidSchema} from \"../../compile/util\"\nimport {validateArray} from \"../code\"\nimport {validateAdditionalItems} from \"./additionalItems\"\n\nexport type ItemsError = ErrorObject<\"items\", {limit: number}, AnySchema>\n\nconst error: KeywordErrorDefinition = {\n message: ({params: {len}}) => str`must NOT have more than ${len} items`,\n params: ({params: {len}}) => _`{limit: ${len}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"items\",\n type: \"array\",\n schemaType: [\"object\", \"boolean\"],\n before: \"uniqueItems\",\n error,\n code(cxt: KeywordCxt) {\n const {schema, parentSchema, it} = cxt\n const {prefixItems} = parentSchema\n it.items = true\n if (alwaysValidSchema(it, schema)) return\n if (prefixItems) validateAdditionalItems(cxt, prefixItems)\n else cxt.ok(validateArray(cxt))\n },\n}\n\nexport default def\n", "import type {\n CodeKeywordDefinition,\n KeywordErrorDefinition,\n ErrorObject,\n AnySchema,\n} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, Name} from \"../../compile/codegen\"\nimport {alwaysValidSchema, checkStrictMode, Type} from \"../../compile/util\"\n\nexport type ContainsError = ErrorObject<\n \"contains\",\n {minContains: number; maxContains?: number},\n AnySchema\n>\n\nconst error: KeywordErrorDefinition = {\n message: ({params: {min, max}}) =>\n max === undefined\n ? str`must contain at least ${min} valid item(s)`\n : str`must contain at least ${min} and no more than ${max} valid item(s)`,\n params: ({params: {min, max}}) =>\n max === undefined ? _`{minContains: ${min}}` : _`{minContains: ${min}, maxContains: ${max}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"contains\",\n type: \"array\",\n schemaType: [\"object\", \"boolean\"],\n before: \"uniqueItems\",\n trackErrors: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, schema, parentSchema, data, it} = cxt\n let min: number\n let max: number | undefined\n const {minContains, maxContains} = parentSchema\n if (it.opts.next) {\n min = minContains === undefined ? 1 : minContains\n max = maxContains\n } else {\n min = 1\n }\n const len = gen.const(\"len\", _`${data}.length`)\n cxt.setParams({min, max})\n if (max === undefined && min === 0) {\n checkStrictMode(it, `\"minContains\" == 0 without \"maxContains\": \"contains\" keyword ignored`)\n return\n }\n if (max !== undefined && min > max) {\n checkStrictMode(it, `\"minContains\" > \"maxContains\" is always invalid`)\n cxt.fail()\n return\n }\n if (alwaysValidSchema(it, schema)) {\n let cond = _`${len} >= ${min}`\n if (max !== undefined) cond = _`${cond} && ${len} <= ${max}`\n cxt.pass(cond)\n return\n }\n\n it.items = true\n const valid = gen.name(\"valid\")\n if (max === undefined && min === 1) {\n validateItems(valid, () => gen.if(valid, () => gen.break()))\n } else if (min === 0) {\n gen.let(valid, true)\n if (max !== undefined) gen.if(_`${data}.length > 0`, validateItemsWithCount)\n } else {\n gen.let(valid, false)\n validateItemsWithCount()\n }\n cxt.result(valid, () => cxt.reset())\n\n function validateItemsWithCount(): void {\n const schValid = gen.name(\"_valid\")\n const count = gen.let(\"count\", 0)\n validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)))\n }\n\n function validateItems(_valid: Name, block: () => void): void {\n gen.forRange(\"i\", 0, len, (i) => {\n cxt.subschema(\n {\n keyword: \"contains\",\n dataProp: i,\n dataPropType: Type.Num,\n compositeRule: true,\n },\n _valid\n )\n block()\n })\n }\n\n function checkLimits(count: Name): void {\n gen.code(_`${count}++`)\n if (max === undefined) {\n gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true).break())\n } else {\n gen.if(_`${count} > ${max}`, () => gen.assign(valid, false).break())\n if (min === 1) gen.assign(valid, true)\n else gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true))\n }\n }\n },\n}\n\nexport default def\n", "import type {\n CodeKeywordDefinition,\n ErrorObject,\n KeywordErrorDefinition,\n SchemaMap,\n AnySchema,\n} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str} from \"../../compile/codegen\"\nimport {alwaysValidSchema} from \"../../compile/util\"\nimport {checkReportMissingProp, checkMissingProp, reportMissingProp, propertyInData} from \"../code\"\n\nexport type PropertyDependencies = {[K in string]?: string[]}\n\nexport interface DependenciesErrorParams {\n property: string\n missingProperty: string\n depsCount: number\n deps: string // TODO change to string[]\n}\n\ntype SchemaDependencies = SchemaMap\n\nexport type DependenciesError = ErrorObject<\n \"dependencies\",\n DependenciesErrorParams,\n {[K in string]?: string[] | AnySchema}\n>\n\nexport const error: KeywordErrorDefinition = {\n message: ({params: {property, depsCount, deps}}) => {\n const property_ies = depsCount === 1 ? \"property\" : \"properties\"\n return str`must have ${property_ies} ${deps} when property ${property} is present`\n },\n params: ({params: {property, depsCount, deps, missingProperty}}) =>\n _`{property: ${property},\n missingProperty: ${missingProperty},\n depsCount: ${depsCount},\n deps: ${deps}}`, // TODO change to reference\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"dependencies\",\n type: \"object\",\n schemaType: \"object\",\n error,\n code(cxt: KeywordCxt) {\n const [propDeps, schDeps] = splitDependencies(cxt)\n validatePropertyDeps(cxt, propDeps)\n validateSchemaDeps(cxt, schDeps)\n },\n}\n\nfunction splitDependencies({schema}: KeywordCxt): [PropertyDependencies, SchemaDependencies] {\n const propertyDeps: PropertyDependencies = {}\n const schemaDeps: SchemaDependencies = {}\n for (const key in schema) {\n if (key === \"__proto__\") continue\n const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps\n deps[key] = schema[key]\n }\n return [propertyDeps, schemaDeps]\n}\n\nexport function validatePropertyDeps(\n cxt: KeywordCxt,\n propertyDeps: {[K in string]?: string[]} = cxt.schema\n): void {\n const {gen, data, it} = cxt\n if (Object.keys(propertyDeps).length === 0) return\n const missing = gen.let(\"missing\")\n for (const prop in propertyDeps) {\n const deps = propertyDeps[prop] as string[]\n if (deps.length === 0) continue\n const hasProperty = propertyInData(gen, data, prop, it.opts.ownProperties)\n cxt.setParams({\n property: prop,\n depsCount: deps.length,\n deps: deps.join(\", \"),\n })\n if (it.allErrors) {\n gen.if(hasProperty, () => {\n for (const depProp of deps) {\n checkReportMissingProp(cxt, depProp)\n }\n })\n } else {\n gen.if(_`${hasProperty} && (${checkMissingProp(cxt, deps, missing)})`)\n reportMissingProp(cxt, missing)\n gen.else()\n }\n }\n}\n\nexport function validateSchemaDeps(cxt: KeywordCxt, schemaDeps: SchemaMap = cxt.schema): void {\n const {gen, data, keyword, it} = cxt\n const valid = gen.name(\"valid\")\n for (const prop in schemaDeps) {\n if (alwaysValidSchema(it, schemaDeps[prop] as AnySchema)) continue\n gen.if(\n propertyInData(gen, data, prop, it.opts.ownProperties),\n () => {\n const schCxt = cxt.subschema({keyword, schemaProp: prop}, valid)\n cxt.mergeValidEvaluated(schCxt, valid)\n },\n () => gen.var(valid, true) // TODO var\n )\n cxt.ok(valid)\n }\n}\n\nexport default def\n", "import type {\n CodeKeywordDefinition,\n ErrorObject,\n KeywordErrorDefinition,\n AnySchema,\n} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, not} from \"../../compile/codegen\"\nimport {alwaysValidSchema} from \"../../compile/util\"\n\nexport type PropertyNamesError = ErrorObject<\"propertyNames\", {propertyName: string}, AnySchema>\n\nconst error: KeywordErrorDefinition = {\n message: \"property name must be valid\",\n params: ({params}) => _`{propertyName: ${params.propertyName}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"propertyNames\",\n type: \"object\",\n schemaType: [\"object\", \"boolean\"],\n error,\n code(cxt: KeywordCxt) {\n const {gen, schema, data, it} = cxt\n if (alwaysValidSchema(it, schema)) return\n const valid = gen.name(\"valid\")\n\n gen.forIn(\"key\", data, (key) => {\n cxt.setParams({propertyName: key})\n cxt.subschema(\n {\n keyword: \"propertyNames\",\n data: key,\n dataTypes: [\"string\"],\n propertyName: key,\n compositeRule: true,\n },\n valid\n )\n gen.if(not(valid), () => {\n cxt.error(true)\n if (!it.allErrors) gen.break()\n })\n })\n\n cxt.ok(valid)\n },\n}\n\nexport default def\n", "import type {\n CodeKeywordDefinition,\n AddedKeywordDefinition,\n ErrorObject,\n KeywordErrorDefinition,\n AnySchema,\n} from \"../../types\"\nimport {allSchemaProperties, usePattern, isOwnProperty} from \"../code\"\nimport {_, nil, or, not, Code, Name} from \"../../compile/codegen\"\nimport N from \"../../compile/names\"\nimport type {SubschemaArgs} from \"../../compile/validate/subschema\"\nimport {alwaysValidSchema, schemaRefOrVal, Type} from \"../../compile/util\"\n\nexport type AdditionalPropertiesError = ErrorObject<\n \"additionalProperties\",\n {additionalProperty: string},\n AnySchema\n>\n\nconst error: KeywordErrorDefinition = {\n message: \"must NOT have additional properties\",\n params: ({params}) => _`{additionalProperty: ${params.additionalProperty}}`,\n}\n\nconst def: CodeKeywordDefinition & AddedKeywordDefinition = {\n keyword: \"additionalProperties\",\n type: [\"object\"],\n schemaType: [\"boolean\", \"object\"],\n allowUndefined: true,\n trackErrors: true,\n error,\n code(cxt) {\n const {gen, schema, parentSchema, data, errsCount, it} = cxt\n /* istanbul ignore if */\n if (!errsCount) throw new Error(\"ajv implementation error\")\n const {allErrors, opts} = it\n it.props = true\n if (opts.removeAdditional !== \"all\" && alwaysValidSchema(it, schema)) return\n const props = allSchemaProperties(parentSchema.properties)\n const patProps = allSchemaProperties(parentSchema.patternProperties)\n checkAdditionalProperties()\n cxt.ok(_`${errsCount} === ${N.errors}`)\n\n function checkAdditionalProperties(): void {\n gen.forIn(\"key\", data, (key: Name) => {\n if (!props.length && !patProps.length) additionalPropertyCode(key)\n else gen.if(isAdditional(key), () => additionalPropertyCode(key))\n })\n }\n\n function isAdditional(key: Name): Code {\n let definedProp: Code\n if (props.length > 8) {\n // TODO maybe an option instead of hard-coded 8?\n const propsSchema = schemaRefOrVal(it, parentSchema.properties, \"properties\")\n definedProp = isOwnProperty(gen, propsSchema as Code, key)\n } else if (props.length) {\n definedProp = or(...props.map((p) => _`${key} === ${p}`))\n } else {\n definedProp = nil\n }\n if (patProps.length) {\n definedProp = or(definedProp, ...patProps.map((p) => _`${usePattern(cxt, p)}.test(${key})`))\n }\n return not(definedProp)\n }\n\n function deleteAdditional(key: Name): void {\n gen.code(_`delete ${data}[${key}]`)\n }\n\n function additionalPropertyCode(key: Name): void {\n if (opts.removeAdditional === \"all\" || (opts.removeAdditional && schema === false)) {\n deleteAdditional(key)\n return\n }\n\n if (schema === false) {\n cxt.setParams({additionalProperty: key})\n cxt.error()\n if (!allErrors) gen.break()\n return\n }\n\n if (typeof schema == \"object\" && !alwaysValidSchema(it, schema)) {\n const valid = gen.name(\"valid\")\n if (opts.removeAdditional === \"failing\") {\n applyAdditionalSchema(key, valid, false)\n gen.if(not(valid), () => {\n cxt.reset()\n deleteAdditional(key)\n })\n } else {\n applyAdditionalSchema(key, valid)\n if (!allErrors) gen.if(not(valid), () => gen.break())\n }\n }\n }\n\n function applyAdditionalSchema(key: Name, valid: Name, errors?: false): void {\n const subschema: SubschemaArgs = {\n keyword: \"additionalProperties\",\n dataProp: key,\n dataPropType: Type.Str,\n }\n if (errors === false) {\n Object.assign(subschema, {\n compositeRule: true,\n createErrors: false,\n allErrors: false,\n })\n }\n cxt.subschema(subschema, valid)\n }\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition} from \"../../types\"\nimport {KeywordCxt} from \"../../compile/validate\"\nimport {propertyInData, allSchemaProperties} from \"../code\"\nimport {alwaysValidSchema, toHash, mergeEvaluated} from \"../../compile/util\"\nimport apDef from \"./additionalProperties\"\n\nconst def: CodeKeywordDefinition = {\n keyword: \"properties\",\n type: \"object\",\n schemaType: \"object\",\n code(cxt: KeywordCxt) {\n const {gen, schema, parentSchema, data, it} = cxt\n if (it.opts.removeAdditional === \"all\" && parentSchema.additionalProperties === undefined) {\n apDef.code(new KeywordCxt(it, apDef, \"additionalProperties\"))\n }\n const allProps = allSchemaProperties(schema)\n for (const prop of allProps) {\n it.definedProperties.add(prop)\n }\n if (it.opts.unevaluated && allProps.length && it.props !== true) {\n it.props = mergeEvaluated.props(gen, toHash(allProps), it.props)\n }\n const properties = allProps.filter((p) => !alwaysValidSchema(it, schema[p]))\n if (properties.length === 0) return\n const valid = gen.name(\"valid\")\n\n for (const prop of properties) {\n if (hasDefault(prop)) {\n applyPropertySchema(prop)\n } else {\n gen.if(propertyInData(gen, data, prop, it.opts.ownProperties))\n applyPropertySchema(prop)\n if (!it.allErrors) gen.else().var(valid, true)\n gen.endIf()\n }\n cxt.it.definedProperties.add(prop)\n cxt.ok(valid)\n }\n\n function hasDefault(prop: string): boolean | undefined {\n return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined\n }\n\n function applyPropertySchema(prop: string): void {\n cxt.subschema(\n {\n keyword: \"properties\",\n schemaProp: prop,\n dataProp: prop,\n },\n valid\n )\n }\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {allSchemaProperties, usePattern} from \"../code\"\nimport {_, not, Name} from \"../../compile/codegen\"\nimport {alwaysValidSchema, checkStrictMode} from \"../../compile/util\"\nimport {evaluatedPropsToName, Type} from \"../../compile/util\"\nimport {AnySchema} from \"../../types\"\n\nconst def: CodeKeywordDefinition = {\n keyword: \"patternProperties\",\n type: \"object\",\n schemaType: \"object\",\n code(cxt: KeywordCxt) {\n const {gen, schema, data, parentSchema, it} = cxt\n const {opts} = it\n const patterns = allSchemaProperties(schema)\n const alwaysValidPatterns = patterns.filter((p) =>\n alwaysValidSchema(it, schema[p] as AnySchema)\n )\n\n if (\n patterns.length === 0 ||\n (alwaysValidPatterns.length === patterns.length &&\n (!it.opts.unevaluated || it.props === true))\n ) {\n return\n }\n\n const checkProperties =\n opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties\n const valid = gen.name(\"valid\")\n if (it.props !== true && !(it.props instanceof Name)) {\n it.props = evaluatedPropsToName(gen, it.props)\n }\n const {props} = it\n validatePatternProperties()\n\n function validatePatternProperties(): void {\n for (const pat of patterns) {\n if (checkProperties) checkMatchingProperties(pat)\n if (it.allErrors) {\n validateProperties(pat)\n } else {\n gen.var(valid, true) // TODO var\n validateProperties(pat)\n gen.if(valid)\n }\n }\n }\n\n function checkMatchingProperties(pat: string): void {\n for (const prop in checkProperties) {\n if (new RegExp(pat).test(prop)) {\n checkStrictMode(\n it,\n `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`\n )\n }\n }\n }\n\n function validateProperties(pat: string): void {\n gen.forIn(\"key\", data, (key) => {\n gen.if(_`${usePattern(cxt, pat)}.test(${key})`, () => {\n const alwaysValid = alwaysValidPatterns.includes(pat)\n if (!alwaysValid) {\n cxt.subschema(\n {\n keyword: \"patternProperties\",\n schemaProp: pat,\n dataProp: key,\n dataPropType: Type.Str,\n },\n valid\n )\n }\n\n if (it.opts.unevaluated && props !== true) {\n gen.assign(_`${props}[${key}]`, true)\n } else if (!alwaysValid && !it.allErrors) {\n // can short-circuit if `unevaluatedProperties` is not supported (opts.next === false)\n // or if all properties were evaluated (props === true)\n gen.if(not(valid), () => gen.break())\n }\n })\n })\n }\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, ErrorNoParams, AnySchema} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {alwaysValidSchema} from \"../../compile/util\"\n\nexport type NotKeywordError = ErrorNoParams<\"not\", AnySchema>\n\nconst def: CodeKeywordDefinition = {\n keyword: \"not\",\n schemaType: [\"object\", \"boolean\"],\n trackErrors: true,\n code(cxt: KeywordCxt) {\n const {gen, schema, it} = cxt\n if (alwaysValidSchema(it, schema)) {\n cxt.fail()\n return\n }\n\n const valid = gen.name(\"valid\")\n cxt.subschema(\n {\n keyword: \"not\",\n compositeRule: true,\n createErrors: false,\n allErrors: false,\n },\n valid\n )\n\n cxt.failResult(\n valid,\n () => cxt.reset(),\n () => cxt.error()\n )\n },\n error: {message: \"must NOT be valid\"},\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, ErrorNoParams, AnySchema} from \"../../types\"\nimport {validateUnion} from \"../code\"\n\nexport type AnyOfError = ErrorNoParams<\"anyOf\", AnySchema[]>\n\nconst def: CodeKeywordDefinition = {\n keyword: \"anyOf\",\n schemaType: \"array\",\n trackErrors: true,\n code: validateUnion,\n error: {message: \"must match a schema in anyOf\"},\n}\n\nexport default def\n", "import type {\n CodeKeywordDefinition,\n ErrorObject,\n KeywordErrorDefinition,\n AnySchema,\n} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, Name} from \"../../compile/codegen\"\nimport {alwaysValidSchema} from \"../../compile/util\"\nimport {SchemaCxt} from \"../../compile\"\n\nexport type OneOfError = ErrorObject<\n \"oneOf\",\n {passingSchemas: [number, number] | null},\n AnySchema[]\n>\n\nconst error: KeywordErrorDefinition = {\n message: \"must match exactly one schema in oneOf\",\n params: ({params}) => _`{passingSchemas: ${params.passing}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"oneOf\",\n schemaType: \"array\",\n trackErrors: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, schema, parentSchema, it} = cxt\n /* istanbul ignore if */\n if (!Array.isArray(schema)) throw new Error(\"ajv implementation error\")\n if (it.opts.discriminator && parentSchema.discriminator) return\n const schArr: AnySchema[] = schema\n const valid = gen.let(\"valid\", false)\n const passing = gen.let(\"passing\", null)\n const schValid = gen.name(\"_valid\")\n cxt.setParams({passing})\n // TODO possibly fail straight away (with warning or exception) if there are two empty always valid schemas\n\n gen.block(validateOneOf)\n\n cxt.result(\n valid,\n () => cxt.reset(),\n () => cxt.error(true)\n )\n\n function validateOneOf(): void {\n schArr.forEach((sch: AnySchema, i: number) => {\n let schCxt: SchemaCxt | undefined\n if (alwaysValidSchema(it, sch)) {\n gen.var(schValid, true)\n } else {\n schCxt = cxt.subschema(\n {\n keyword: \"oneOf\",\n schemaProp: i,\n compositeRule: true,\n },\n schValid\n )\n }\n\n if (i > 0) {\n gen\n .if(_`${schValid} && ${valid}`)\n .assign(valid, false)\n .assign(passing, _`[${passing}, ${i}]`)\n .else()\n }\n\n gen.if(schValid, () => {\n gen.assign(valid, true)\n gen.assign(passing, i)\n if (schCxt) cxt.mergeEvaluated(schCxt, Name)\n })\n })\n }\n },\n}\n\nexport default def\n", "import type {CodeKeywordDefinition, AnySchema} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {alwaysValidSchema} from \"../../compile/util\"\n\nconst def: CodeKeywordDefinition = {\n keyword: \"allOf\",\n schemaType: \"array\",\n code(cxt: KeywordCxt) {\n const {gen, schema, it} = cxt\n /* istanbul ignore if */\n if (!Array.isArray(schema)) throw new Error(\"ajv implementation error\")\n const valid = gen.name(\"valid\")\n schema.forEach((sch: AnySchema, i: number) => {\n if (alwaysValidSchema(it, sch)) return\n const schCxt = cxt.subschema({keyword: \"allOf\", schemaProp: i}, valid)\n cxt.ok(valid)\n cxt.mergeEvaluated(schCxt)\n })\n },\n}\n\nexport default def\n", "import type {\n CodeKeywordDefinition,\n ErrorObject,\n KeywordErrorDefinition,\n AnySchema,\n} from \"../../types\"\nimport type {SchemaObjCxt} from \"../../compile\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, not, Name} from \"../../compile/codegen\"\nimport {alwaysValidSchema, checkStrictMode} from \"../../compile/util\"\n\nexport type IfKeywordError = ErrorObject<\"if\", {failingKeyword: string}, AnySchema>\n\nconst error: KeywordErrorDefinition = {\n message: ({params}) => str`must match \"${params.ifClause}\" schema`,\n params: ({params}) => _`{failingKeyword: ${params.ifClause}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"if\",\n schemaType: [\"object\", \"boolean\"],\n trackErrors: true,\n error,\n code(cxt: KeywordCxt) {\n const {gen, parentSchema, it} = cxt\n if (parentSchema.then === undefined && parentSchema.else === undefined) {\n checkStrictMode(it, '\"if\" without \"then\" and \"else\" is ignored')\n }\n const hasThen = hasSchema(it, \"then\")\n const hasElse = hasSchema(it, \"else\")\n if (!hasThen && !hasElse) return\n\n const valid = gen.let(\"valid\", true)\n const schValid = gen.name(\"_valid\")\n validateIf()\n cxt.reset()\n\n if (hasThen && hasElse) {\n const ifClause = gen.let(\"ifClause\")\n cxt.setParams({ifClause})\n gen.if(schValid, validateClause(\"then\", ifClause), validateClause(\"else\", ifClause))\n } else if (hasThen) {\n gen.if(schValid, validateClause(\"then\"))\n } else {\n gen.if(not(schValid), validateClause(\"else\"))\n }\n\n cxt.pass(valid, () => cxt.error(true))\n\n function validateIf(): void {\n const schCxt = cxt.subschema(\n {\n keyword: \"if\",\n compositeRule: true,\n createErrors: false,\n allErrors: false,\n },\n schValid\n )\n cxt.mergeEvaluated(schCxt)\n }\n\n function validateClause(keyword: string, ifClause?: Name): () => void {\n return () => {\n const schCxt = cxt.subschema({keyword}, schValid)\n gen.assign(valid, schValid)\n cxt.mergeValidEvaluated(schCxt, valid)\n if (ifClause) gen.assign(ifClause, _`${keyword}`)\n else cxt.setParams({ifClause: keyword})\n }\n }\n },\n}\n\nfunction hasSchema(it: SchemaObjCxt, keyword: string): boolean {\n const schema = it.schema[keyword]\n return schema !== undefined && !alwaysValidSchema(it, schema)\n}\n\nexport default def\n", "import type {CodeKeywordDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {checkStrictMode} from \"../../compile/util\"\n\nconst def: CodeKeywordDefinition = {\n keyword: [\"then\", \"else\"],\n schemaType: [\"object\", \"boolean\"],\n code({keyword, parentSchema, it}: KeywordCxt) {\n if (parentSchema.if === undefined) checkStrictMode(it, `\"${keyword}\" without \"if\" is ignored`)\n },\n}\n\nexport default def\n", "import type {ErrorNoParams, Vocabulary} from \"../../types\"\nimport additionalItems, {AdditionalItemsError} from \"./additionalItems\"\nimport prefixItems from \"./prefixItems\"\nimport items from \"./items\"\nimport items2020, {ItemsError} from \"./items2020\"\nimport contains, {ContainsError} from \"./contains\"\nimport dependencies, {DependenciesError} from \"./dependencies\"\nimport propertyNames, {PropertyNamesError} from \"./propertyNames\"\nimport additionalProperties, {AdditionalPropertiesError} from \"./additionalProperties\"\nimport properties from \"./properties\"\nimport patternProperties from \"./patternProperties\"\nimport notKeyword, {NotKeywordError} from \"./not\"\nimport anyOf, {AnyOfError} from \"./anyOf\"\nimport oneOf, {OneOfError} from \"./oneOf\"\nimport allOf from \"./allOf\"\nimport ifKeyword, {IfKeywordError} from \"./if\"\nimport thenElse from \"./thenElse\"\n\nexport default function getApplicator(draft2020 = false): Vocabulary {\n const applicator = [\n // any\n notKeyword,\n anyOf,\n oneOf,\n allOf,\n ifKeyword,\n thenElse,\n // object\n propertyNames,\n additionalProperties,\n dependencies,\n properties,\n patternProperties,\n ]\n // array\n if (draft2020) applicator.push(prefixItems, items2020)\n else applicator.push(additionalItems, items)\n applicator.push(contains)\n return applicator\n}\n\nexport type ApplicatorKeywordError =\n | ErrorNoParams<\"false schema\">\n | AdditionalItemsError\n | ItemsError\n | ContainsError\n | AdditionalPropertiesError\n | DependenciesError\n | IfKeywordError\n | AnyOfError\n | OneOfError\n | NotKeywordError\n | PropertyNamesError\n", "import type {\n AddedFormat,\n FormatValidator,\n AsyncFormatValidator,\n CodeKeywordDefinition,\n KeywordErrorDefinition,\n ErrorObject,\n} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, str, nil, or, Code, getProperty, regexpCode} from \"../../compile/codegen\"\n\ntype FormatValidate =\n | FormatValidator\n | FormatValidator\n | AsyncFormatValidator\n | AsyncFormatValidator\n | RegExp\n | string\n | true\n\nexport type FormatError = ErrorObject<\"format\", {format: string}, string | {$data: string}>\n\nconst error: KeywordErrorDefinition = {\n message: ({schemaCode}) => str`must match format \"${schemaCode}\"`,\n params: ({schemaCode}) => _`{format: ${schemaCode}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"format\",\n type: [\"number\", \"string\"],\n schemaType: \"string\",\n $data: true,\n error,\n code(cxt: KeywordCxt, ruleType?: string) {\n const {gen, data, $data, schema, schemaCode, it} = cxt\n const {opts, errSchemaPath, schemaEnv, self} = it\n if (!opts.validateFormats) return\n\n if ($data) validate$DataFormat()\n else validateFormat()\n\n function validate$DataFormat(): void {\n const fmts = gen.scopeValue(\"formats\", {\n ref: self.formats,\n code: opts.code.formats,\n })\n const fDef = gen.const(\"fDef\", _`${fmts}[${schemaCode}]`)\n const fType = gen.let(\"fType\")\n const format = gen.let(\"format\")\n // TODO simplify\n gen.if(\n _`typeof ${fDef} == \"object\" && !(${fDef} instanceof RegExp)`,\n () => gen.assign(fType, _`${fDef}.type || \"string\"`).assign(format, _`${fDef}.validate`),\n () => gen.assign(fType, _`\"string\"`).assign(format, fDef)\n )\n cxt.fail$data(or(unknownFmt(), invalidFmt()))\n\n function unknownFmt(): Code {\n if (opts.strictSchema === false) return nil\n return _`${schemaCode} && !${format}`\n }\n\n function invalidFmt(): Code {\n const callFormat = schemaEnv.$async\n ? _`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))`\n : _`${format}(${data})`\n const validData = _`(typeof ${format} == \"function\" ? ${callFormat} : ${format}.test(${data}))`\n return _`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`\n }\n }\n\n function validateFormat(): void {\n const formatDef: AddedFormat | undefined = self.formats[schema]\n if (!formatDef) {\n unknownFormat()\n return\n }\n if (formatDef === true) return\n const [fmtType, format, fmtRef] = getFormat(formatDef)\n if (fmtType === ruleType) cxt.pass(validCondition())\n\n function unknownFormat(): void {\n if (opts.strictSchema === false) {\n self.logger.warn(unknownMsg())\n return\n }\n throw new Error(unknownMsg())\n\n function unknownMsg(): string {\n return `unknown format \"${schema as string}\" ignored in schema at path \"${errSchemaPath}\"`\n }\n }\n\n function getFormat(fmtDef: AddedFormat): [string, FormatValidate, Code] {\n const code =\n fmtDef instanceof RegExp\n ? regexpCode(fmtDef)\n : opts.code.formats\n ? _`${opts.code.formats}${getProperty(schema)}`\n : undefined\n const fmt = gen.scopeValue(\"formats\", {key: schema, ref: fmtDef, code})\n if (typeof fmtDef == \"object\" && !(fmtDef instanceof RegExp)) {\n return [fmtDef.type || \"string\", fmtDef.validate, _`${fmt}.validate`]\n }\n\n return [\"string\", fmtDef, fmt]\n }\n\n function validCondition(): Code {\n if (typeof formatDef == \"object\" && !(formatDef instanceof RegExp) && formatDef.async) {\n if (!schemaEnv.$async) throw new Error(\"async format in sync schema\")\n return _`await ${fmtRef}(${data})`\n }\n return typeof format == \"function\" ? _`${fmtRef}(${data})` : _`${fmtRef}.test(${data})`\n }\n }\n },\n}\n\nexport default def\n", "import type {Vocabulary} from \"../../types\"\nimport formatKeyword from \"./format\"\n\nconst format: Vocabulary = [formatKeyword]\n\nexport default format\n", "import type {Vocabulary} from \"../types\"\n\nexport const metadataVocabulary: Vocabulary = [\n \"title\",\n \"description\",\n \"default\",\n \"deprecated\",\n \"readOnly\",\n \"writeOnly\",\n \"examples\",\n]\n\nexport const contentVocabulary: Vocabulary = [\n \"contentMediaType\",\n \"contentEncoding\",\n \"contentSchema\",\n]\n", "import type {Vocabulary} from \"../types\"\nimport coreVocabulary from \"./core\"\nimport validationVocabulary from \"./validation\"\nimport getApplicatorVocabulary from \"./applicator\"\nimport formatVocabulary from \"./format\"\nimport {metadataVocabulary, contentVocabulary} from \"./metadata\"\n\nconst draft7Vocabularies: Vocabulary[] = [\n coreVocabulary,\n validationVocabulary,\n getApplicatorVocabulary(),\n formatVocabulary,\n metadataVocabulary,\n contentVocabulary,\n]\n\nexport default draft7Vocabularies\n", "import type {ErrorObject} from \"../../types\"\n\nexport enum DiscrError {\n Tag = \"tag\",\n Mapping = \"mapping\",\n}\n\nexport type DiscrErrorObj = ErrorObject<\n \"discriminator\",\n {error: E; tag: string; tagValue: unknown},\n string\n>\n", "import type {CodeKeywordDefinition, AnySchemaObject, KeywordErrorDefinition} from \"../../types\"\nimport type {KeywordCxt} from \"../../compile/validate\"\nimport {_, getProperty, Name} from \"../../compile/codegen\"\nimport {DiscrError, DiscrErrorObj} from \"../discriminator/types\"\nimport {resolveRef, SchemaEnv} from \"../../compile\"\nimport MissingRefError from \"../../compile/ref_error\"\nimport {schemaHasRulesButRef} from \"../../compile/util\"\n\nexport type DiscriminatorError = DiscrErrorObj | DiscrErrorObj\n\nconst error: KeywordErrorDefinition = {\n message: ({params: {discrError, tagName}}) =>\n discrError === DiscrError.Tag\n ? `tag \"${tagName}\" must be string`\n : `value of tag \"${tagName}\" must be in oneOf`,\n params: ({params: {discrError, tag, tagName}}) =>\n _`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,\n}\n\nconst def: CodeKeywordDefinition = {\n keyword: \"discriminator\",\n type: \"object\",\n schemaType: \"object\",\n error,\n code(cxt: KeywordCxt) {\n const {gen, data, schema, parentSchema, it} = cxt\n const {oneOf} = parentSchema\n if (!it.opts.discriminator) {\n throw new Error(\"discriminator: requires discriminator option\")\n }\n const tagName = schema.propertyName\n if (typeof tagName != \"string\") throw new Error(\"discriminator: requires propertyName\")\n if (schema.mapping) throw new Error(\"discriminator: mapping is not supported\")\n if (!oneOf) throw new Error(\"discriminator: requires oneOf keyword\")\n const valid = gen.let(\"valid\", false)\n const tag = gen.const(\"tag\", _`${data}${getProperty(tagName)}`)\n gen.if(\n _`typeof ${tag} == \"string\"`,\n () => validateMapping(),\n () => cxt.error(false, {discrError: DiscrError.Tag, tag, tagName})\n )\n cxt.ok(valid)\n\n function validateMapping(): void {\n const mapping = getMapping()\n gen.if(false)\n for (const tagValue in mapping) {\n gen.elseIf(_`${tag} === ${tagValue}`)\n gen.assign(valid, applyTagSchema(mapping[tagValue]))\n }\n gen.else()\n cxt.error(false, {discrError: DiscrError.Mapping, tag, tagName})\n gen.endIf()\n }\n\n function applyTagSchema(schemaProp?: number): Name {\n const _valid = gen.name(\"valid\")\n const schCxt = cxt.subschema({keyword: \"oneOf\", schemaProp}, _valid)\n cxt.mergeEvaluated(schCxt, Name)\n return _valid\n }\n\n function getMapping(): {[T in string]?: number} {\n const oneOfMapping: {[T in string]?: number} = {}\n const topRequired = hasRequired(parentSchema)\n let tagRequired = true\n for (let i = 0; i < oneOf.length; i++) {\n let sch = oneOf[i]\n if (sch?.$ref && !schemaHasRulesButRef(sch, it.self.RULES)) {\n const ref = sch.$ref\n sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)\n if (sch instanceof SchemaEnv) sch = sch.schema\n if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)\n }\n const propSch = sch?.properties?.[tagName]\n if (typeof propSch != \"object\") {\n throw new Error(\n `discriminator: oneOf subschemas (or referenced schemas) must have \"properties/${tagName}\"`\n )\n }\n tagRequired = tagRequired && (topRequired || hasRequired(sch))\n addMappings(propSch, i)\n }\n if (!tagRequired) throw new Error(`discriminator: \"${tagName}\" must be required`)\n return oneOfMapping\n\n function hasRequired({required}: AnySchemaObject): boolean {\n return Array.isArray(required) && required.includes(tagName)\n }\n\n function addMappings(sch: AnySchemaObject, i: number): void {\n if (sch.const) {\n addMapping(sch.const, i)\n } else if (sch.enum) {\n for (const tagValue of sch.enum) {\n addMapping(tagValue, i)\n }\n } else {\n throw new Error(`discriminator: \"properties/${tagName}\" must have \"const\" or \"enum\"`)\n }\n }\n\n function addMapping(tagValue: unknown, i: number): void {\n if (typeof tagValue != \"string\" || tagValue in oneOfMapping) {\n throw new Error(`discriminator: \"${tagName}\" values must be unique strings`)\n }\n oneOfMapping[tagValue] = i\n }\n }\n },\n}\n\nexport default def\n", "{\n \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n \"$id\": \"http://json-schema.org/draft-07/schema#\",\n \"title\": \"Core schema meta-schema\",\n \"definitions\": {\n \"schemaArray\": {\n \"type\": \"array\",\n \"minItems\": 1,\n \"items\": {\"$ref\": \"#\"}\n },\n \"nonNegativeInteger\": {\n \"type\": \"integer\",\n \"minimum\": 0\n },\n \"nonNegativeIntegerDefault0\": {\n \"allOf\": [{\"$ref\": \"#/definitions/nonNegativeInteger\"}, {\"default\": 0}]\n },\n \"simpleTypes\": {\n \"enum\": [\"array\", \"boolean\", \"integer\", \"null\", \"number\", \"object\", \"string\"]\n },\n \"stringArray\": {\n \"type\": \"array\",\n \"items\": {\"type\": \"string\"},\n \"uniqueItems\": true,\n \"default\": []\n }\n },\n \"type\": [\"object\", \"boolean\"],\n \"properties\": {\n \"$id\": {\n \"type\": \"string\",\n \"format\": \"uri-reference\"\n },\n \"$schema\": {\n \"type\": \"string\",\n \"format\": \"uri\"\n },\n \"$ref\": {\n \"type\": \"string\",\n \"format\": \"uri-reference\"\n },\n \"$comment\": {\n \"type\": \"string\"\n },\n \"title\": {\n \"type\": \"string\"\n },\n \"description\": {\n \"type\": \"string\"\n },\n \"default\": true,\n \"readOnly\": {\n \"type\": \"boolean\",\n \"default\": false\n },\n \"examples\": {\n \"type\": \"array\",\n \"items\": true\n },\n \"multipleOf\": {\n \"type\": \"number\",\n \"exclusiveMinimum\": 0\n },\n \"maximum\": {\n \"type\": \"number\"\n },\n \"exclusiveMaximum\": {\n \"type\": \"number\"\n },\n \"minimum\": {\n \"type\": \"number\"\n },\n \"exclusiveMinimum\": {\n \"type\": \"number\"\n },\n \"maxLength\": {\"$ref\": \"#/definitions/nonNegativeInteger\"},\n \"minLength\": {\"$ref\": \"#/definitions/nonNegativeIntegerDefault0\"},\n \"pattern\": {\n \"type\": \"string\",\n \"format\": \"regex\"\n },\n \"additionalItems\": {\"$ref\": \"#\"},\n \"items\": {\n \"anyOf\": [{\"$ref\": \"#\"}, {\"$ref\": \"#/definitions/schemaArray\"}],\n \"default\": true\n },\n \"maxItems\": {\"$ref\": \"#/definitions/nonNegativeInteger\"},\n \"minItems\": {\"$ref\": \"#/definitions/nonNegativeIntegerDefault0\"},\n \"uniqueItems\": {\n \"type\": \"boolean\",\n \"default\": false\n },\n \"contains\": {\"$ref\": \"#\"},\n \"maxProperties\": {\"$ref\": \"#/definitions/nonNegativeInteger\"},\n \"minProperties\": {\"$ref\": \"#/definitions/nonNegativeIntegerDefault0\"},\n \"required\": {\"$ref\": \"#/definitions/stringArray\"},\n \"additionalProperties\": {\"$ref\": \"#\"},\n \"definitions\": {\n \"type\": \"object\",\n \"additionalProperties\": {\"$ref\": \"#\"},\n \"default\": {}\n },\n \"properties\": {\n \"type\": \"object\",\n \"additionalProperties\": {\"$ref\": \"#\"},\n \"default\": {}\n },\n \"patternProperties\": {\n \"type\": \"object\",\n \"additionalProperties\": {\"$ref\": \"#\"},\n \"propertyNames\": {\"format\": \"regex\"},\n \"default\": {}\n },\n \"dependencies\": {\n \"type\": \"object\",\n \"additionalProperties\": {\n \"anyOf\": [{\"$ref\": \"#\"}, {\"$ref\": \"#/definitions/stringArray\"}]\n }\n },\n \"propertyNames\": {\"$ref\": \"#\"},\n \"const\": true,\n \"enum\": {\n \"type\": \"array\",\n \"items\": true,\n \"minItems\": 1,\n \"uniqueItems\": true\n },\n \"type\": {\n \"anyOf\": [\n {\"$ref\": \"#/definitions/simpleTypes\"},\n {\n \"type\": \"array\",\n \"items\": {\"$ref\": \"#/definitions/simpleTypes\"},\n \"minItems\": 1,\n \"uniqueItems\": true\n }\n ]\n },\n \"format\": {\"type\": \"string\"},\n \"contentMediaType\": {\"type\": \"string\"},\n \"contentEncoding\": {\"type\": \"string\"},\n \"if\": {\"$ref\": \"#\"},\n \"then\": {\"$ref\": \"#\"},\n \"else\": {\"$ref\": \"#\"},\n \"allOf\": {\"$ref\": \"#/definitions/schemaArray\"},\n \"anyOf\": {\"$ref\": \"#/definitions/schemaArray\"},\n \"oneOf\": {\"$ref\": \"#/definitions/schemaArray\"},\n \"not\": {\"$ref\": \"#\"}\n },\n \"default\": true\n}\n", "import type {AnySchemaObject} from \"./types\"\nimport AjvCore from \"./core\"\nimport draft7Vocabularies from \"./vocabularies/draft7\"\nimport discriminator from \"./vocabularies/discriminator\"\nimport * as draft7MetaSchema from \"./refs/json-schema-draft-07.json\"\n\nconst META_SUPPORT_DATA = [\"/properties\"]\n\nconst META_SCHEMA_ID = \"http://json-schema.org/draft-07/schema\"\n\nexport class Ajv extends AjvCore {\n _addVocabularies(): void {\n super._addVocabularies()\n draft7Vocabularies.forEach((v) => this.addVocabulary(v))\n if (this.opts.discriminator) this.addKeyword(discriminator)\n }\n\n _addDefaultMetaSchema(): void {\n super._addDefaultMetaSchema()\n if (!this.opts.meta) return\n const metaSchema = this.opts.$data\n ? this.$dataMetaSchema(draft7MetaSchema, META_SUPPORT_DATA)\n : draft7MetaSchema\n this.addMetaSchema(metaSchema, META_SCHEMA_ID, false)\n this.refs[\"http://json-schema.org/schema\"] = META_SCHEMA_ID\n }\n\n defaultMeta(): string | AnySchemaObject | undefined {\n return (this.opts.defaultMeta =\n super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : undefined))\n }\n}\n\nmodule.exports = exports = Ajv\nmodule.exports.Ajv = Ajv\nObject.defineProperty(exports, \"__esModule\", {value: true})\n\nexport default Ajv\n\nexport {\n Format,\n FormatDefinition,\n AsyncFormatDefinition,\n KeywordDefinition,\n KeywordErrorDefinition,\n CodeKeywordDefinition,\n MacroKeywordDefinition,\n FuncKeywordDefinition,\n Vocabulary,\n Schema,\n SchemaObject,\n AnySchemaObject,\n AsyncSchema,\n AnySchema,\n ValidateFunction,\n AsyncValidateFunction,\n SchemaValidateFunction,\n ErrorObject,\n ErrorNoParams,\n} from \"./types\"\n\nexport {Plugin, Options, CodeOptions, InstanceOptions, Logger, ErrorsTextOptions} from \"./core\"\nexport {SchemaCxt, SchemaObjCxt} from \"./compile\"\nexport {KeywordCxt} from \"./compile/validate\"\nexport {DefinedError} from \"./vocabularies/errors\"\nexport {JSONType} from \"./compile/rules\"\nexport {JSONSchemaType} from \"./types/json-schema\"\nexport {_, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions} from \"./compile/codegen\"\nexport {default as ValidationError} from \"./runtime/validation_error\"\nexport {default as MissingRefError} from \"./compile/ref_error\"\n", "import type {Format, FormatDefinition} from \"ajv\"\nimport type {FormatValidator, FormatCompare} from \"ajv/dist/types\"\n\nexport type FormatMode = \"fast\" | \"full\"\n\nexport type FormatName =\n | \"date\"\n | \"time\"\n | \"date-time\"\n | \"iso-time\"\n | \"iso-date-time\"\n | \"duration\"\n | \"uri\"\n | \"uri-reference\"\n | \"uri-template\"\n | \"url\"\n | \"email\"\n | \"hostname\"\n | \"ipv4\"\n | \"ipv6\"\n | \"regex\"\n | \"uuid\"\n | \"json-pointer\"\n | \"json-pointer-uri-fragment\"\n | \"relative-json-pointer\"\n | \"byte\"\n | \"int32\"\n | \"int64\"\n | \"float\"\n | \"double\"\n | \"password\"\n | \"binary\"\n\nexport type DefinedFormats = {\n [key in FormatName]: Format\n}\n\nfunction fmtDef(\n validate: RegExp | FormatValidator,\n compare: FormatCompare\n): FormatDefinition {\n return {validate, compare}\n}\n\nexport const fullFormats: DefinedFormats = {\n // date: http://tools.ietf.org/html/rfc3339#section-5.6\n date: fmtDef(date, compareDate),\n // date-time: http://tools.ietf.org/html/rfc3339#section-5.6\n time: fmtDef(getTime(true), compareTime),\n \"date-time\": fmtDef(getDateTime(true), compareDateTime),\n \"iso-time\": fmtDef(getTime(), compareIsoTime),\n \"iso-date-time\": fmtDef(getDateTime(), compareIsoDateTime),\n // duration: https://tools.ietf.org/html/rfc3339#appendix-A\n duration: /^P(?!$)((\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?|(\\d+W)?)$/,\n uri,\n \"uri-reference\":\n /^(?:[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,\n // uri-template: https://tools.ietf.org/html/rfc6570\n \"uri-template\":\n /^(?:(?:[^\\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,\n // For the source: https://gist.github.com/dperini/729294\n // For test cases: https://mathiasbynens.be/demo/url-regex\n url: /^(?:https?|ftp):\\/\\/(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|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-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)(?:\\.(?:[a-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)*(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu,\n email:\n /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,\n hostname:\n /^(?=.{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,\n // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html\n 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)$/,\n 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,\n regex,\n // uuid: http://tools.ietf.org/html/rfc4122\n uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,\n // JSON-pointer: https://tools.ietf.org/html/rfc6901\n // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A\n \"json-pointer\": /^(?:\\/(?:[^~/]|~0|~1)*)*$/,\n \"json-pointer-uri-fragment\": /^#(?:\\/(?:[a-z0-9_\\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,\n // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00\n \"relative-json-pointer\": /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/,\n // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types\n // byte: https://github.com/miguelmota/is-base64\n byte,\n // signed 32 bit integer\n int32: {type: \"number\", validate: validateInt32},\n // signed 64 bit integer\n int64: {type: \"number\", validate: validateInt64},\n // C-type float\n float: {type: \"number\", validate: validateNumber},\n // C-type double\n double: {type: \"number\", validate: validateNumber},\n // hint to the UI to hide input strings\n password: true,\n // unchecked string payload\n binary: true,\n}\n\nexport const fastFormats: DefinedFormats = {\n ...fullFormats,\n date: fmtDef(/^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d$/, compareDate),\n time: fmtDef(\n /^(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)$/i,\n compareTime\n ),\n \"date-time\": fmtDef(\n /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\dt(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)$/i,\n compareDateTime\n ),\n \"iso-time\": fmtDef(\n /^(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)?$/i,\n compareIsoTime\n ),\n \"iso-date-time\": fmtDef(\n /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d[t\\s](?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)?$/i,\n compareIsoDateTime\n ),\n // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js\n uri: /^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/)?[^\\s]*$/i,\n \"uri-reference\": /^(?:(?:[a-z][a-z0-9+\\-.]*:)?\\/?\\/)?(?:[^\\\\\\s#][^\\s#]*)?(?:#[^\\\\\\s]*)?$/i,\n // email (sources from jsen validator):\n // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363\n // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation')\n email:\n /^[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,\n}\n\nexport const formatNames = Object.keys(fullFormats) as FormatName[]\n\nfunction isLeapYear(year: number): boolean {\n // https://tools.ietf.org/html/rfc3339#appendix-C\n return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)\n}\n\nconst DATE = /^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)$/\nconst DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n\nfunction date(str: string): boolean {\n // full-date from http://tools.ietf.org/html/rfc3339#section-5.6\n const matches: string[] | null = DATE.exec(str)\n if (!matches) return false\n const year: number = +matches[1]\n const month: number = +matches[2]\n const day: number = +matches[3]\n return (\n month >= 1 &&\n month <= 12 &&\n day >= 1 &&\n day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month])\n )\n}\n\nfunction compareDate(d1: string, d2: string): number | undefined {\n if (!(d1 && d2)) return undefined\n if (d1 > d2) return 1\n if (d1 < d2) return -1\n return 0\n}\n\nconst TIME = /^(\\d\\d):(\\d\\d):(\\d\\d(?:\\.\\d+)?)(z|([+-])(\\d\\d)(?::?(\\d\\d))?)?$/i\n\nfunction getTime(strictTimeZone?: boolean): (str: string) => boolean {\n return function time(str: string): boolean {\n const matches: string[] | null = TIME.exec(str)\n if (!matches) return false\n const hr: number = +matches[1]\n const min: number = +matches[2]\n const sec: number = +matches[3]\n const tz: string | undefined = matches[4]\n const tzSign: number = matches[5] === \"-\" ? -1 : 1\n const tzH: number = +(matches[6] || 0)\n const tzM: number = +(matches[7] || 0)\n if (tzH > 23 || tzM > 59 || (strictTimeZone && !tz)) return false\n if (hr <= 23 && min <= 59 && sec < 60) return true\n // leap second\n const utcMin = min - tzM * tzSign\n const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0)\n return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61\n }\n}\n\nfunction compareTime(s1: string, s2: string): number | undefined {\n if (!(s1 && s2)) return undefined\n const t1 = new Date(\"2020-01-01T\" + s1).valueOf()\n const t2 = new Date(\"2020-01-01T\" + s2).valueOf()\n if (!(t1 && t2)) return undefined\n return t1 - t2\n}\n\nfunction compareIsoTime(t1: string, t2: string): number | undefined {\n if (!(t1 && t2)) return undefined\n const a1 = TIME.exec(t1)\n const a2 = TIME.exec(t2)\n if (!(a1 && a2)) return undefined\n t1 = a1[1] + a1[2] + a1[3]\n t2 = a2[1] + a2[2] + a2[3]\n if (t1 > t2) return 1\n if (t1 < t2) return -1\n return 0\n}\n\nconst DATE_TIME_SEPARATOR = /t|\\s/i\nfunction getDateTime(strictTimeZone?: boolean): (str: string) => boolean {\n const time = getTime(strictTimeZone)\n\n return function date_time(str: string): boolean {\n // http://tools.ietf.org/html/rfc3339#section-5.6\n const dateTime: string[] = str.split(DATE_TIME_SEPARATOR)\n return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1])\n }\n}\n\nfunction compareDateTime(dt1: string, dt2: string): number | undefined {\n if (!(dt1 && dt2)) return undefined\n const d1 = new Date(dt1).valueOf()\n const d2 = new Date(dt2).valueOf()\n if (!(d1 && d2)) return undefined\n return d1 - d2\n}\n\nfunction compareIsoDateTime(dt1: string, dt2: string): number | undefined {\n if (!(dt1 && dt2)) return undefined\n const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR)\n const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR)\n const res = compareDate(d1, d2)\n if (res === undefined) return undefined\n return res || compareTime(t1, t2)\n}\n\nconst NOT_URI_FRAGMENT = /\\/|:/\nconst URI =\n /^(?:[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\n\nfunction uri(str: string): boolean {\n // http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required \".\"\n return NOT_URI_FRAGMENT.test(str) && URI.test(str)\n}\n\nconst BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm\n\nfunction byte(str: string): boolean {\n BYTE.lastIndex = 0\n return BYTE.test(str)\n}\n\nconst MIN_INT32 = -(2 ** 31)\nconst MAX_INT32 = 2 ** 31 - 1\n\nfunction validateInt32(value: number): boolean {\n return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32\n}\n\nfunction validateInt64(value: number): boolean {\n // JSON and javascript max Int is 2**53, so any int that passes isInteger is valid for Int64\n return Number.isInteger(value)\n}\n\nfunction validateNumber(): boolean {\n return true\n}\n\nconst Z_ANCHOR = /[^\\\\]\\\\Z/\nfunction regex(str: string): boolean {\n if (Z_ANCHOR.test(str)) return false\n try {\n new RegExp(str)\n return true\n } catch (e) {\n return false\n }\n}\n", "import type Ajv from \"ajv\"\nimport type {\n Plugin,\n CodeKeywordDefinition,\n KeywordErrorDefinition,\n Code,\n Name,\n ErrorObject,\n} from \"ajv\"\nimport type {AddedFormat} from \"ajv/dist/types\"\nimport type {Rule} from \"ajv/dist/compile/rules\"\nimport {KeywordCxt} from \"ajv\"\nimport {_, str, or, getProperty, operators} from \"ajv/dist/compile/codegen\"\n\ntype Kwd = \"formatMaximum\" | \"formatMinimum\" | \"formatExclusiveMaximum\" | \"formatExclusiveMinimum\"\n\ntype Comparison = \"<=\" | \">=\" | \"<\" | \">\"\n\nconst ops = operators\n\nconst KWDs: {[K in Kwd]: {okStr: Comparison; ok: Code; fail: Code}} = {\n formatMaximum: {okStr: \"<=\", ok: ops.LTE, fail: ops.GT},\n formatMinimum: {okStr: \">=\", ok: ops.GTE, fail: ops.LT},\n formatExclusiveMaximum: {okStr: \"<\", ok: ops.LT, fail: ops.GTE},\n formatExclusiveMinimum: {okStr: \">\", ok: ops.GT, fail: ops.LTE},\n}\n\nexport type LimitFormatError = ErrorObject\n\nconst error: KeywordErrorDefinition = {\n message: ({keyword, schemaCode}) => str`should be ${KWDs[keyword as Kwd].okStr} ${schemaCode}`,\n params: ({keyword, schemaCode}) =>\n _`{comparison: ${KWDs[keyword as Kwd].okStr}, limit: ${schemaCode}}`,\n}\n\nexport const formatLimitDefinition: CodeKeywordDefinition = {\n keyword: Object.keys(KWDs),\n type: \"string\",\n schemaType: \"string\",\n $data: true,\n error,\n code(cxt) {\n const {gen, data, schemaCode, keyword, it} = cxt\n const {opts, self} = it\n if (!opts.validateFormats) return\n\n const fCxt = new KeywordCxt(it, (self.RULES.all.format as Rule).definition, \"format\")\n if (fCxt.$data) validate$DataFormat()\n else validateFormat()\n\n function validate$DataFormat(): void {\n const fmts = gen.scopeValue(\"formats\", {\n ref: self.formats,\n code: opts.code.formats,\n })\n const fmt = gen.const(\"fmt\", _`${fmts}[${fCxt.schemaCode}]`)\n cxt.fail$data(\n or(\n _`typeof ${fmt} != \"object\"`,\n _`${fmt} instanceof RegExp`,\n _`typeof ${fmt}.compare != \"function\"`,\n compareCode(fmt)\n )\n )\n }\n\n function validateFormat(): void {\n const format = fCxt.schema as string\n const fmtDef: AddedFormat | undefined = self.formats[format]\n if (!fmtDef || fmtDef === true) return\n if (\n typeof fmtDef != \"object\" ||\n fmtDef instanceof RegExp ||\n typeof fmtDef.compare != \"function\"\n ) {\n throw new Error(`\"${keyword}\": format \"${format}\" does not define \"compare\" function`)\n }\n const fmt = gen.scopeValue(\"formats\", {\n key: format,\n ref: fmtDef,\n code: opts.code.formats ? _`${opts.code.formats}${getProperty(format)}` : undefined,\n })\n\n cxt.fail$data(compareCode(fmt))\n }\n\n function compareCode(fmt: Name): Code {\n return _`${fmt}.compare(${data}, ${schemaCode}) ${KWDs[keyword as Kwd].fail} 0`\n }\n },\n dependencies: [\"format\"],\n}\n\nconst formatLimitPlugin: Plugin = (ajv: Ajv): Ajv => {\n ajv.addKeyword(formatLimitDefinition)\n return ajv\n}\n\nexport default formatLimitPlugin\n", "import {\n DefinedFormats,\n FormatMode,\n FormatName,\n formatNames,\n fastFormats,\n fullFormats,\n} from \"./formats\"\nimport formatLimit from \"./limit\"\nimport type Ajv from \"ajv\"\nimport type {Plugin, Format} from \"ajv\"\nimport {_, Name} from \"ajv/dist/compile/codegen\"\n\nexport {FormatMode, FormatName} from \"./formats\"\nexport {LimitFormatError} from \"./limit\"\nexport interface FormatOptions {\n mode?: FormatMode\n formats?: FormatName[]\n keywords?: boolean\n}\n\nexport type FormatsPluginOptions = FormatName[] | FormatOptions\n\nexport interface FormatsPlugin extends Plugin {\n get: (format: FormatName, mode?: FormatMode) => Format\n}\n\nconst fullName = new Name(\"fullFormats\")\nconst fastName = new Name(\"fastFormats\")\n\nconst formatsPlugin: FormatsPlugin = (\n ajv: Ajv,\n opts: FormatsPluginOptions = {keywords: true}\n): Ajv => {\n if (Array.isArray(opts)) {\n addFormats(ajv, opts, fullFormats, fullName)\n return ajv\n }\n const [formats, exportName] =\n opts.mode === \"fast\" ? [fastFormats, fastName] : [fullFormats, fullName]\n const list = opts.formats || formatNames\n addFormats(ajv, list, formats, exportName)\n if (opts.keywords) formatLimit(ajv)\n return ajv\n}\n\nformatsPlugin.get = (name: FormatName, mode: FormatMode = \"full\"): Format => {\n const formats = mode === \"fast\" ? fastFormats : fullFormats\n const f = formats[name]\n if (!f) throw new Error(`Unknown format \"${name}\"`)\n return f\n}\n\nfunction addFormats(ajv: Ajv, list: FormatName[], fs: DefinedFormats, exportName: Name): void {\n ajv.opts.code.formats ??= _`require(\"ajv-formats/dist/formats\").${exportName}`\n for (const f of list) ajv.addFormat(f, fs[f])\n}\n\nmodule.exports = exports = formatsPlugin\nObject.defineProperty(exports, \"__esModule\", {value: true})\n\nexport default formatsPlugin\n", "{\n \"name\": \"dotenv\",\n \"version\": \"16.6.1\",\n \"description\": \"Loads environment variables from .env file\",\n \"main\": \"lib/main.js\",\n \"types\": \"lib/main.d.ts\",\n \"exports\": {\n \".\": {\n \"types\": \"./lib/main.d.ts\",\n \"require\": \"./lib/main.js\",\n \"default\": \"./lib/main.js\"\n },\n \"./config\": \"./config.js\",\n \"./config.js\": \"./config.js\",\n \"./lib/env-options\": \"./lib/env-options.js\",\n \"./lib/env-options.js\": \"./lib/env-options.js\",\n \"./lib/cli-options\": \"./lib/cli-options.js\",\n \"./lib/cli-options.js\": \"./lib/cli-options.js\",\n \"./package.json\": \"./package.json\"\n },\n \"scripts\": {\n \"dts-check\": \"tsc --project tests/types/tsconfig.json\",\n \"lint\": \"standard\",\n \"pretest\": \"npm run lint && npm run dts-check\",\n \"test\": \"tap run --allow-empty-coverage --disable-coverage --timeout=60000\",\n \"test:coverage\": \"tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov\",\n \"prerelease\": \"npm test\",\n \"release\": \"standard-version\"\n },\n \"repository\": {\n \"type\": \"git\",\n \"url\": \"git://github.com/motdotla/dotenv.git\"\n },\n \"homepage\": \"https://github.com/motdotla/dotenv#readme\",\n \"funding\": \"https://dotenvx.com\",\n \"keywords\": [\n \"dotenv\",\n \"env\",\n \".env\",\n \"environment\",\n \"variables\",\n \"config\",\n \"settings\"\n ],\n \"readmeFilename\": \"README.md\",\n \"license\": \"BSD-2-Clause\",\n \"devDependencies\": {\n \"@types/node\": \"^18.11.3\",\n \"decache\": \"^4.6.2\",\n \"sinon\": \"^14.0.1\",\n \"standard\": \"^17.0.0\",\n \"standard-version\": \"^9.5.0\",\n \"tap\": \"^19.2.0\",\n \"typescript\": \"^4.8.4\"\n },\n \"engines\": {\n \"node\": \">=12\"\n },\n \"browser\": {\n \"fs\": false\n }\n}\n", "const fs = require('fs')\nconst path = require('path')\nconst os = require('os')\nconst crypto = require('crypto')\nconst packageJson = require('../package.json')\n\nconst version = packageJson.version\n\nconst LINE = /(?:^|^)\\s*(?:export\\s+)?([\\w.-]+)(?:\\s*=\\s*?|:\\s+?)(\\s*'(?:\\\\'|[^'])*'|\\s*\"(?:\\\\\"|[^\"])*\"|\\s*`(?:\\\\`|[^`])*`|[^#\\r\\n]+)?\\s*(?:#.*)?(?:$|$)/mg\n\n// Parse src into an Object\nfunction parse (src) {\n const obj = {}\n\n // Convert buffer to string\n let lines = src.toString()\n\n // Convert line breaks to same format\n lines = lines.replace(/\\r\\n?/mg, '\\n')\n\n let match\n while ((match = LINE.exec(lines)) != null) {\n const key = match[1]\n\n // Default undefined or null to empty string\n let value = (match[2] || '')\n\n // Remove whitespace\n value = value.trim()\n\n // Check if double quoted\n const maybeQuote = value[0]\n\n // Remove surrounding quotes\n value = value.replace(/^(['\"`])([\\s\\S]*)\\1$/mg, '$2')\n\n // Expand newlines if double quoted\n if (maybeQuote === '\"') {\n value = value.replace(/\\\\n/g, '\\n')\n value = value.replace(/\\\\r/g, '\\r')\n }\n\n // Add to object\n obj[key] = value\n }\n\n return obj\n}\n\nfunction _parseVault (options) {\n options = options || {}\n\n const vaultPath = _vaultPath(options)\n options.path = vaultPath // parse .env.vault\n const result = DotenvModule.configDotenv(options)\n if (!result.parsed) {\n const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`)\n err.code = 'MISSING_DATA'\n throw err\n }\n\n // handle scenario for comma separated keys - for use with key rotation\n // example: DOTENV_KEY=\"dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod\"\n const keys = _dotenvKey(options).split(',')\n const length = keys.length\n\n let decrypted\n for (let i = 0; i < length; i++) {\n try {\n // Get full key\n const key = keys[i].trim()\n\n // Get instructions for decrypt\n const attrs = _instructions(result, key)\n\n // Decrypt\n decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key)\n\n break\n } catch (error) {\n // last key\n if (i + 1 >= length) {\n throw error\n }\n // try next key\n }\n }\n\n // Parse decrypted .env string\n return DotenvModule.parse(decrypted)\n}\n\nfunction _warn (message) {\n console.log(`[dotenv@${version}][WARN] ${message}`)\n}\n\nfunction _debug (message) {\n console.log(`[dotenv@${version}][DEBUG] ${message}`)\n}\n\nfunction _log (message) {\n console.log(`[dotenv@${version}] ${message}`)\n}\n\nfunction _dotenvKey (options) {\n // prioritize developer directly setting options.DOTENV_KEY\n if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {\n return options.DOTENV_KEY\n }\n\n // secondary infra already contains a DOTENV_KEY environment variable\n if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {\n return process.env.DOTENV_KEY\n }\n\n // fallback to empty string\n return ''\n}\n\nfunction _instructions (result, dotenvKey) {\n // Parse DOTENV_KEY. Format is a URI\n let uri\n try {\n uri = new URL(dotenvKey)\n } catch (error) {\n if (error.code === 'ERR_INVALID_URL') {\n const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development')\n err.code = 'INVALID_DOTENV_KEY'\n throw err\n }\n\n throw error\n }\n\n // Get decrypt key\n const key = uri.password\n if (!key) {\n const err = new Error('INVALID_DOTENV_KEY: Missing key part')\n err.code = 'INVALID_DOTENV_KEY'\n throw err\n }\n\n // Get environment\n const environment = uri.searchParams.get('environment')\n if (!environment) {\n const err = new Error('INVALID_DOTENV_KEY: Missing environment part')\n err.code = 'INVALID_DOTENV_KEY'\n throw err\n }\n\n // Get ciphertext payload\n const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`\n const ciphertext = result.parsed[environmentKey] // DOTENV_VAULT_PRODUCTION\n if (!ciphertext) {\n const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`)\n err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT'\n throw err\n }\n\n return { ciphertext, key }\n}\n\nfunction _vaultPath (options) {\n let possibleVaultPath = null\n\n if (options && options.path && options.path.length > 0) {\n if (Array.isArray(options.path)) {\n for (const filepath of options.path) {\n if (fs.existsSync(filepath)) {\n possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`\n }\n }\n } else {\n possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`\n }\n } else {\n possibleVaultPath = path.resolve(process.cwd(), '.env.vault')\n }\n\n if (fs.existsSync(possibleVaultPath)) {\n return possibleVaultPath\n }\n\n return null\n}\n\nfunction _resolveHome (envPath) {\n return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath\n}\n\nfunction _configVault (options) {\n const debug = Boolean(options && options.debug)\n const quiet = options && 'quiet' in options ? options.quiet : true\n\n if (debug || !quiet) {\n _log('Loading env from encrypted .env.vault')\n }\n\n const parsed = DotenvModule._parseVault(options)\n\n let processEnv = process.env\n if (options && options.processEnv != null) {\n processEnv = options.processEnv\n }\n\n DotenvModule.populate(processEnv, parsed, options)\n\n return { parsed }\n}\n\nfunction configDotenv (options) {\n const dotenvPath = path.resolve(process.cwd(), '.env')\n let encoding = 'utf8'\n const debug = Boolean(options && options.debug)\n const quiet = options && 'quiet' in options ? options.quiet : true\n\n if (options && options.encoding) {\n encoding = options.encoding\n } else {\n if (debug) {\n _debug('No encoding is specified. UTF-8 is used by default')\n }\n }\n\n let optionPaths = [dotenvPath] // default, look for .env\n if (options && options.path) {\n if (!Array.isArray(options.path)) {\n optionPaths = [_resolveHome(options.path)]\n } else {\n optionPaths = [] // reset default\n for (const filepath of options.path) {\n optionPaths.push(_resolveHome(filepath))\n }\n }\n }\n\n // Build the parsed data in a temporary object (because we need to return it). Once we have the final\n // parsed data, we will combine it with process.env (or options.processEnv if provided).\n let lastError\n const parsedAll = {}\n for (const path of optionPaths) {\n try {\n // Specifying an encoding returns a string instead of a buffer\n const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }))\n\n DotenvModule.populate(parsedAll, parsed, options)\n } catch (e) {\n if (debug) {\n _debug(`Failed to load ${path} ${e.message}`)\n }\n lastError = e\n }\n }\n\n let processEnv = process.env\n if (options && options.processEnv != null) {\n processEnv = options.processEnv\n }\n\n DotenvModule.populate(processEnv, parsedAll, options)\n\n if (debug || !quiet) {\n const keysCount = Object.keys(parsedAll).length\n const shortPaths = []\n for (const filePath of optionPaths) {\n try {\n const relative = path.relative(process.cwd(), filePath)\n shortPaths.push(relative)\n } catch (e) {\n if (debug) {\n _debug(`Failed to load ${filePath} ${e.message}`)\n }\n lastError = e\n }\n }\n\n _log(`injecting env (${keysCount}) from ${shortPaths.join(',')}`)\n }\n\n if (lastError) {\n return { parsed: parsedAll, error: lastError }\n } else {\n return { parsed: parsedAll }\n }\n}\n\n// Populates process.env from .env file\nfunction config (options) {\n // fallback to original dotenv if DOTENV_KEY is not set\n if (_dotenvKey(options).length === 0) {\n return DotenvModule.configDotenv(options)\n }\n\n const vaultPath = _vaultPath(options)\n\n // dotenvKey exists but .env.vault file does not exist\n if (!vaultPath) {\n _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`)\n\n return DotenvModule.configDotenv(options)\n }\n\n return DotenvModule._configVault(options)\n}\n\nfunction decrypt (encrypted, keyStr) {\n const key = Buffer.from(keyStr.slice(-64), 'hex')\n let ciphertext = Buffer.from(encrypted, 'base64')\n\n const nonce = ciphertext.subarray(0, 12)\n const authTag = ciphertext.subarray(-16)\n ciphertext = ciphertext.subarray(12, -16)\n\n try {\n const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce)\n aesgcm.setAuthTag(authTag)\n return `${aesgcm.update(ciphertext)}${aesgcm.final()}`\n } catch (error) {\n const isRange = error instanceof RangeError\n const invalidKeyLength = error.message === 'Invalid key length'\n const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data'\n\n if (isRange || invalidKeyLength) {\n const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)')\n err.code = 'INVALID_DOTENV_KEY'\n throw err\n } else if (decryptionFailed) {\n const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY')\n err.code = 'DECRYPTION_FAILED'\n throw err\n } else {\n throw error\n }\n }\n}\n\n// Populate process.env with parsed values\nfunction populate (processEnv, parsed, options = {}) {\n const debug = Boolean(options && options.debug)\n const override = Boolean(options && options.override)\n\n if (typeof parsed !== 'object') {\n const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate')\n err.code = 'OBJECT_REQUIRED'\n throw err\n }\n\n // Set process.env\n for (const key of Object.keys(parsed)) {\n if (Object.prototype.hasOwnProperty.call(processEnv, key)) {\n if (override === true) {\n processEnv[key] = parsed[key]\n }\n\n if (debug) {\n if (override === true) {\n _debug(`\"${key}\" is already defined and WAS overwritten`)\n } else {\n _debug(`\"${key}\" is already defined and was NOT overwritten`)\n }\n }\n } else {\n processEnv[key] = parsed[key]\n }\n }\n}\n\nconst DotenvModule = {\n configDotenv,\n _configVault,\n _parseVault,\n config,\n decrypt,\n parse,\n populate\n}\n\nmodule.exports.configDotenv = DotenvModule.configDotenv\nmodule.exports._configVault = DotenvModule._configVault\nmodule.exports._parseVault = DotenvModule._parseVault\nmodule.exports.config = DotenvModule.config\nmodule.exports.decrypt = DotenvModule.decrypt\nmodule.exports.parse = DotenvModule.parse\nmodule.exports.populate = DotenvModule.populate\n\nmodule.exports = DotenvModule\n", "import * as fs from 'fs/promises';\nimport {WebSocketServer, WebSocket} from 'ws';\nimport {createServer} from 'http';\nimport {parse} from 'url';\nimport {fork, execSync} from 'child_process';\nimport {runMcpServer} from './server.js';\nimport {\n clearTokens,\n deleteToken, generateNewRegistrationToken,\n generateToken,\n getToken,\n loadAuthorizedTokens,\n saveAuthorizedTokens, saveServerTokenToEnv,\n setToken\n} from \"./tokens.js\";\nimport {\n CONFIG,\n HOST,\n PID_FILE,\n SERVER_TOKEN,\n ensureConfigDir,\n formatChannel,\n setConfig,\n configureMcpClient,\n} from './config.js';\n\nlet serverToken = SERVER_TOKEN;\n\n// Create HTTP server with CORS headers\nconst httpServer = createServer(async (req, res) => {\n // Set CORS headers\n res.setHeader('Access-Control-Allow-Origin', '*');\n res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');\n res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');\n\n if (req.method === 'OPTIONS') {\n // Handle preflight requests\n res.writeHead(204);\n res.end();\n return;\n }\n\n // Parse URL\n const url = new URL(`http://${HOST}${req.url}`);\n\n // Endpoint: POST /token - Genera un nuevo token de registro\n if (url.pathname === '/token' && req.method === 'POST') {\n try {\n const token = await generateNewRegistrationToken();\n res.writeHead(200, { 'Content-Type': 'application/json' });\n res.end(JSON.stringify({\n success: true,\n token: token\n }));\n } catch (error) {\n console.error('Error generating token:', error);\n res.writeHead(500, { 'Content-Type': 'application/json' });\n res.end(JSON.stringify({ error: 'Failed to generate token' }));\n }\n return;\n }\n\n // Endpoint: GET /status - Estado del servidor\n if (url.pathname === '/status' && req.method === 'GET') {\n res.writeHead(200, { 'Content-Type': 'application/json' });\n res.end(JSON.stringify({\n status: 'running',\n clients: wss.clients.size,\n version: '0.2.0'\n }));\n return;\n }\n\n // Default response\n res.writeHead(200, {'Content-Type': 'text/plain'});\n res.end('MCP WebSocket server is running');\n});\n\n// Create WebSocket server instance\nconst wss = new WebSocketServer({\n server: httpServer,\n clientTracking: true,\n verifyClient: verifyClientToken\n});\n\n// Store active WebSocket connections by channel\nconst channels = {};\n\n// Store browser metadata per WebSocket connection\nconst clientMetadata = new Map();\n\n// Special channel paths\nconst MCP_PATH = '/mcp';\nconst REGISTER_PATH = '/register';\n\n// Function to send notifications to a client and MCP (if connected)\nfunction sendNotification(clientWs, channelPath, notificationType, data, mcpOnly = false) {\n // Send to the client that initiated the action\n if (clientWs && clientWs.readyState === WebSocket.OPEN) {\n if (!mcpOnly) {\n clientWs.send(JSON.stringify({\n type: notificationType,\n ...data\n }));\n }\n }\n\n // Also send to MCP if connected\n if (channels[MCP_PATH] && channels[MCP_PATH].size > 0) {\n try {\n for (const mcpClient of channels[MCP_PATH]) {\n if (mcpClient && mcpClient.readyState === WebSocket.OPEN) {\n // For MCP, prefix names with the channel path\n const mcpData = {...data};\n if (mcpData.name && channelPath) {\n mcpData.name = `${channelPath.slice(1)}-${mcpData.name}`;\n }\n\n mcpClient.send(JSON.stringify({\n type: notificationType,\n ...mcpData\n }));\n }\n }\n } catch (e) {\n console.error('Error sending notification to MCP:', e.message);\n }\n }\n}\n\n// Track all available tools, prompts, and resources across all channels\nconst toolsRegistry = {};\nconst promptsRegistry = {};\nconst resourcesRegistry = {};\n\n// Server start timestamp for uptime calculation\nconst serverStartTime = Date.now();\n\n// Git commit hash (read once at startup)\nlet gitCommit = 'unknown';\ntry {\n gitCommit = execSync('git rev-parse --short HEAD', { stdio: ['pipe', 'pipe', 'ignore'] }).toString().trim();\n} catch (e) {\n // Not in a git repo or git not available\n}\n\n// Request counter for unique IDs\nlet requestIdCounter = 1;\n\n// Map to store pending requests\nconst pendingRequests = {};\n\n\n// Function to verify client token during WebSocket handshake\nasync function verifyClientToken(info, callback) {\n const url = new URL(`https://${HOST}${info.req.url}`);\n const clientToken = url.searchParams.get('token');\n const path = url.pathname || '/';\n\n // Special case for MCP path - use server token from .env\n if (path === MCP_PATH) {\n // For MCP connections, we use the token from the .env file\n if (clientToken === process.env.WEBMCP_SERVER_TOKEN) {\n return callback(true);\n }\n console.error('Invalid MCP token provided');\n return callback(false, 401, 'Unauthorized - Invalid MCP token');\n }\n\n // Special case for registration path - allow all connections for now\n // The actual authorization will happen in the connection handler\n if (path === REGISTER_PATH) {\n return callback(true);\n }\n\n // For other paths, check if the channel-token pair is authorized\n if (!clientToken) {\n console.error('No token provided for path:', path);\n return callback(false, 401, 'Unauthorized - No token provided');\n }\n\n await loadAuthorizedTokens();\n\n // Check if this channel has a valid token and it matches\n if (getToken(path) === clientToken) {\n return callback(true);\n }\n\n console.error(`Unauthorized connection attempt to ${path}`);\n return callback(false, 401, 'Unauthorized - Invalid channel-token pair');\n}\n\n// Helper function to get or create a channel\nfunction getOrCreateChannel(channelPath) {\n if (!channels[channelPath]) {\n channels[channelPath] = new Set();\n console.error(`Created new channel for path: ${channelPath}`);\n } else if (channels[channelPath].closeTimeout) {\n // Clear the timeout if it exists (someone is joining an empty channel)\n clearTimeout(channels[channelPath].closeTimeout);\n delete channels[channelPath].closeTimeout;\n console.error(`Cancelled channel closure for ${channelPath} as a new client connected`);\n }\n return channels[channelPath];\n}\n\n// Handle WebSocket connections\nwss.on('connection', (ws, req) => {\n // Extract the path from the URL\n const parsedUrl = parse(req.url);\n const path = parsedUrl.pathname;\n\n // Set channel based on connection path\n const clientChannel = path || '/';\n\n console.error(`Client connected from ${req.socket.remoteAddress} to path: ${clientChannel}`);\n\n // Special handling for registration endpoint\n if (clientChannel === REGISTER_PATH) {\n console.error(`Registration request received from ${req.socket.remoteAddress}`);\n\n // Wait for the first message which should contain the registration data\n let registrationTimeout = setTimeout(() => {\n console.error('Registration timeout - closing connection');\n ws.close(1008, 'Registration timeout');\n }, 30000); // 30 second timeout\n\n // Register message handler specifically for registration\n ws.once('message', async (message) => {\n clearTimeout(registrationTimeout);\n\n try {\n // The message should be base64 encoded JSON with server and token\n const encodedData = message.toString();\n const decodedJson = Buffer.from(encodedData, 'base64').toString('utf8');\n const connectionData = JSON.parse(decodedJson);\n\n const {host, token} = connectionData;\n\n if (!token) {\n console.error('Invalid registration data format - missing token');\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Invalid registration data format - missing token'\n }));\n ws.close(1008, 'Invalid registration data');\n return;\n }\n\n // Format the channel path (replace : with _)\n const channelPath = formatChannel(host);\n\n // Check if this is a valid token from a \"--new\" command\n if (!token || token.length < 16) {\n console.error('Invalid token provided');\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Invalid token provided'\n }));\n ws.close(1008, 'Invalid token');\n return;\n }\n\n const serverChannel = formatChannel(`${HOST}:${CONFIG.port}`);\n\n await loadAuthorizedTokens();\n if (token !== getToken(serverChannel)) {\n console.error('Invalid token provided');\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Invalid token provided'\n }));\n ws.close(1008, 'Invalid token');\n return;\n }\n\n // Throw away registration token and make a session token.\n deleteToken(serverChannel);\n const sessionToken = generateToken();\n\n // Authorize the channel-token pair\n setToken(channelPath, sessionToken);\n await saveAuthorizedTokens();\n\n // Send success response\n ws.send(JSON.stringify({\n type: 'registerSuccess',\n channel: channelPath,\n message: `Registration successful for ${channelPath}`,\n token: sessionToken\n }));\n\n console.error(`Registered channel: ${channelPath} with token: ${token}`);\n\n // Close the registration connection - they'll reconnect to their channel\n ws.close(1000, 'Registration complete');\n } catch (error) {\n console.error('Registration error:', error);\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Registration error'\n }));\n ws.close(1011, 'Registration error');\n }\n });\n\n return; // Don't proceed with the normal connection handling\n }\n\n // Add client to the channel based on path (for non-registration paths)\n const channel = getOrCreateChannel(clientChannel);\n channel.add(ws);\n\n // Send welcome message with channel info\n ws.send(JSON.stringify({\n type: 'welcome',\n channel: clientChannel,\n message: `Connected to path: ${clientChannel}`\n }));\n\n // Handle incoming messages\n ws.on('message', (message) => {\n try {\n const data = JSON.parse(message);\n console.error(`Received message: ${data.type} on ${clientChannel}`);\n\n // Process message based on type\n switch (data.type) {\n case 'ping':\n handlePing(ws, data);\n break;\n\n case 'registerTool':\n handleRegisterTool(ws, clientChannel, data);\n break;\n\n case 'registerPrompt':\n handleRegisterPrompt(ws, clientChannel, data);\n break;\n\n case 'registerResource':\n handleRegisterResource(ws, clientChannel, data);\n break;\n\n case 'unregisterTool':\n handleUnregisterTool(ws, clientChannel, data);\n break;\n\n case 'unregisterPrompt':\n handleUnregisterPrompt(ws, clientChannel, data);\n break;\n\n case 'unregisterResource':\n handleUnregisterResource(ws, clientChannel, data);\n break;\n\n case 'unregisterAllTools':\n handleUnregisterAllTools(ws, clientChannel);\n break;\n\n case 'listTools':\n handleListTools(ws, clientChannel, data);\n break;\n\n case 'listPrompts':\n handleListPrompts(ws, clientChannel, data);\n break;\n\n case 'listResources':\n handleListResources(ws, clientChannel, data);\n break;\n\n case 'callTool':\n handleCallTool(ws, clientChannel, data);\n break;\n\n case 'getPrompt':\n handleGetPrompt(ws, clientChannel, data);\n break;\n\n case 'readResource':\n handleReadResource(ws, clientChannel, data);\n break;\n\n case 'createSamplingMessage':\n handleCreateSamplingMessage(ws, clientChannel, data);\n break;\n\n case 'toolResponse':\n handleToolResponse(data);\n break;\n\n case 'promptResponse':\n handlePromptResponse(data);\n break;\n\n case 'resourceResponse':\n handleResourceResponse(data);\n break;\n\n case 'samplingResponse':\n handleSamplingResponse(data);\n break;\n\n case 'clipboardCopy':\n handleClipboardCopy(data);\n break;\n\n case 'clientInfo':\n handleClientInfo(ws, data);\n break;\n\n case 'clientInfoResponse':\n handleToolResponse(data);\n break;\n\n case 'getClientInfo':\n handleGetClientInfo(ws, clientChannel, data);\n break;\n\n case 'getServerInfo':\n handleGetServerInfo(ws, data);\n break;\n\n case 'clearRegistry':\n handleClearRegistry(ws, data);\n break;\n\n case 'createTool':\n handleCreateTool(ws, data);\n break;\n\n case 'removeTool':\n handleRemoveTool(ws, data);\n break;\n\n default:\n ws.send(JSON.stringify({\n type: 'error',\n message: `Unknown message type: ${data.type}`\n }));\n }\n } catch (error) {\n const msgPreview = typeof message === 'string' ? message.slice(0, 200) : String(message).slice(0, 200);\n console.error(`Error processing WebSocket message on ${clientChannel}:`, error.message, '\\nRaw message preview:', msgPreview);\n try {\n ws.send(JSON.stringify({\n type: 'error',\n message: `Error: ${error.message}`\n }));\n } catch (sendError) {\n console.error('Error sending error response:', sendError);\n }\n }\n });\n\n // Handle disconnection\n ws.on('close', async () => {\n console.error(`Client disconnected from path: ${clientChannel}`);\n\n // Remove browser metadata\n clientMetadata.delete(ws);\n\n // Remove from channel\n const channel = channels[clientChannel];\n if (channel) {\n channel.delete(ws);\n\n // Set a timer to clean up empty channels after 1 minute\n if (channel.size === 0) {\n console.error(`Channel ${clientChannel} is empty, will close in 1 minute if no one joins`);\n\n // Store the timeout in the channel object so we can clear it if needed\n channel.closeTimeout = setTimeout(async () => {\n // Check if the channel is still empty after 1 minute\n if (channels[clientChannel] && channels[clientChannel].size === 0) {\n delete channels[clientChannel];\n console.error(`Removed empty channel for path: ${clientChannel} after 1 minute inactivity`);\n\n // Clean up tools, prompts, and resources for this channel\n const itemsToRemove = {\n tools: [],\n prompts: [],\n resources: []\n };\n\n for (const [toolId, toolInfo] of Object.entries(toolsRegistry)) {\n if (toolInfo.channel === clientChannel) {\n itemsToRemove.tools.push(toolId);\n }\n }\n\n for (const [promptId, promptInfo] of Object.entries(promptsRegistry)) {\n if (promptInfo.channel === clientChannel) {\n itemsToRemove.prompts.push(promptId);\n }\n }\n\n for (const [resourceId, resourceInfo] of Object.entries(resourcesRegistry)) {\n if (resourceInfo.channel === clientChannel) {\n itemsToRemove.resources.push(resourceId);\n }\n }\n\n itemsToRemove.tools.forEach(toolId => {\n delete toolsRegistry[toolId];\n console.error(`Removed tool: ${toolId} from path: ${clientChannel}`);\n });\n\n itemsToRemove.prompts.forEach(promptId => {\n delete promptsRegistry[promptId];\n console.error(`Removed prompt: ${promptId} from path: ${clientChannel}`);\n });\n\n itemsToRemove.resources.forEach(resourceId => {\n delete resourcesRegistry[resourceId];\n console.error(`Removed resource: ${resourceId} from path: ${clientChannel}`);\n });\n\n // Remove the authorized token for this channel if not MCP\n if (clientChannel !== MCP_PATH) {\n deleteToken(clientChannel);\n await saveAuthorizedTokens();\n console.error(`Removed authorized token for channel: ${clientChannel}`);\n }\n\n // Update them all\n sendNotification(ws, undefined, 'toolRegistered', {}, true);\n sendNotification(ws, undefined, 'promptRegistered', {}, true);\n sendNotification(ws, undefined, 'resourceRegistered', {}, true);\n }\n }, 60000); // 1 minute timeout\n }\n }\n });\n\n // Handle errors\n ws.on('error', (error) => {\n console.error('WebSocket error:', error);\n\n // Remove browser metadata\n clientMetadata.delete(ws);\n\n // Remove from channel\n const channel = channels[clientChannel];\n if (channel) {\n channel.delete(ws);\n }\n });\n});\n\n// Handle ping messages\nfunction handlePing(ws, data) {\n ws.send(JSON.stringify({\n id: data.id,\n type: 'pong',\n timestamp: Date.now()\n }));\n}\n\n// Handle tool registration\nfunction handleRegisterTool(ws, channelPath, data) {\n const {name, description, inputSchema} = data;\n\n if (!name) {\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Tool name is required'\n }));\n return;\n }\n\n // Create a unique tool ID for internal tracking\n const toolId = `${channelPath.slice(1)}-${name}`;\n\n // Register the tool\n toolsRegistry[toolId] = {\n channel: channelPath,\n name,\n description: description || `Tool: ${name}`,\n inputSchema,\n originalName: name\n };\n\n // Send registration notification to both client and MCP\n sendNotification(ws, channelPath, 'toolRegistered', {\n name,\n toolId\n });\n\n console.error(`Tool registered: ${toolId}`);\n}\n\n// Handle prompt registration\nfunction handleRegisterPrompt(ws, channelPath, data) {\n const {name, description, arguments: promptArgs} = data;\n\n if (!name) {\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Prompt name is required'\n }));\n return;\n }\n\n // Create a unique prompt ID for internal tracking\n const promptId = `${channelPath.slice(1)}-${name}`;\n\n // Register the prompt\n promptsRegistry[promptId] = {\n channel: channelPath,\n name,\n description: description || `Prompt: ${name}`,\n arguments: promptArgs || [],\n originalName: name\n };\n\n // Send registration notification to both client and MCP\n sendNotification(ws, channelPath, 'promptRegistered', {\n name,\n promptId\n });\n\n console.error(`Prompt registered: ${promptId}`);\n}\n\n// Handle resource registration\nfunction handleRegisterResource(ws, channelPath, data) {\n const {uri, name, description, mimeType, isTemplate, uriTemplate} = data;\n\n if ((!uri && !uriTemplate) || !name) {\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Resource URI/template and name are required'\n }));\n return;\n }\n\n // Create a unique resource ID for internal tracking\n const resourceId = `${channelPath.slice(1)}-${name}`;\n\n // Register the resource\n resourcesRegistry[resourceId] = {\n channel: channelPath,\n name,\n description: description || `Resource: ${name}`,\n uri: uri,\n uriTemplate: uriTemplate,\n isTemplate: !!isTemplate,\n mimeType,\n originalName: name\n };\n\n // Send registration notification to both client and MCP\n sendNotification(ws, channelPath, 'resourceRegistered', {\n name,\n resourceId\n });\n\n console.error(`Resource registered: ${resourceId}`);\n}\n\n// Handle tool unregistration\nfunction handleUnregisterTool(ws, channelPath, data) {\n const {name} = data;\n\n if (!name) {\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Tool name is required'\n }));\n return;\n }\n\n const toolId = `${channelPath.slice(1)}-${name}`;\n\n if (!toolsRegistry[toolId]) {\n ws.send(JSON.stringify({\n type: 'error',\n message: `Tool not found: ${name}`\n }));\n return;\n }\n\n delete toolsRegistry[toolId];\n\n sendNotification(ws, channelPath, 'toolRegistered', {\n name,\n toolId\n });\n\n console.error(`Tool unregistered: ${toolId}`);\n}\n\n// Handle prompt unregistration\nfunction handleUnregisterPrompt(ws, channelPath, data) {\n const {name} = data;\n\n if (!name) {\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Prompt name is required'\n }));\n return;\n }\n\n const promptId = `${channelPath.slice(1)}-${name}`;\n\n if (!promptsRegistry[promptId]) {\n ws.send(JSON.stringify({\n type: 'error',\n message: `Prompt not found: ${name}`\n }));\n return;\n }\n\n delete promptsRegistry[promptId];\n\n sendNotification(ws, channelPath, 'promptRegistered', {\n name,\n promptId\n });\n\n console.error(`Prompt unregistered: ${promptId}`);\n}\n\n// Handle resource unregistration\nfunction handleUnregisterResource(ws, channelPath, data) {\n const {name} = data;\n\n if (!name) {\n ws.send(JSON.stringify({\n type: 'error',\n message: 'Resource name is required'\n }));\n return;\n }\n\n const resourceId = `${channelPath.slice(1)}-${name}`;\n\n if (!resourcesRegistry[resourceId]) {\n ws.send(JSON.stringify({\n type: 'error',\n message: `Resource not found: ${name}`\n }));\n return;\n }\n\n delete resourcesRegistry[resourceId];\n\n sendNotification(ws, channelPath, 'resourceRegistered', {\n name,\n resourceId\n });\n\n console.error(`Resource unregistered: ${resourceId}`);\n}\n\n// Handle batch unregistration of all tools for a channel\nfunction handleUnregisterAllTools(ws, channelPath) {\n const removed = [];\n for (const [toolId, toolInfo] of Object.entries(toolsRegistry)) {\n if (toolInfo.channel === channelPath) {\n removed.push(toolId);\n }\n }\n\n removed.forEach(toolId => {\n delete toolsRegistry[toolId];\n });\n\n if (removed.length > 0) {\n sendNotification(ws, channelPath, 'toolRegistered', {}, true);\n console.error(`Batch unregistered ${removed.length} tools from ${channelPath}`);\n }\n}\n\n// Handle createTool - forward to web clients to create and register\nfunction handleCreateTool(ws, data) {\n const {id, name, description, code, parametros} = data;\n\n // Find a web client to forward to\n let targetClient = null;\n let targetChannel = null;\n for (const [channelPath, clients] of Object.entries(channels)) {\n if (channelPath === MCP_PATH) continue;\n if (clients.size > 0) {\n targetClient = clients.values().next().value;\n targetChannel = channelPath;\n break;\n }\n }\n\n if (!targetClient) {\n ws.send(JSON.stringify({\n id,\n type: 'toolResponse',\n error: 'No hay navegadores conectados para crear la herramienta'\n }));\n return;\n }\n\n const requestId = (requestIdCounter++).toString();\n pendingRequests[requestId] = { originalId: id, requesterWs: ws, timestamp: Date.now() };\n\n setTimeout(() => {\n if (pendingRequests[requestId]) {\n const {requesterWs, originalId} = pendingRequests[requestId];\n delete pendingRequests[requestId];\n try {\n requesterWs.send(JSON.stringify({ id: originalId, type: 'toolResponse', error: 'Timeout creando herramienta' }));\n } catch (e) {}\n }\n }, 15000);\n\n targetClient.send(JSON.stringify({\n id: requestId,\n type: 'createTool',\n name, description, code, parametros\n }));\n\n console.error(`createTool forwarded to ${targetChannel}: ${name}`);\n}\n\n// Handle removeTool - list or remove tools from registry\nfunction handleRemoveTool(ws, data) {\n const {id, name, listar, todas} = data;\n\n if (listar) {\n const tools = Object.entries(toolsRegistry)\n .filter(([_, info]) => info.channel !== MCP_PATH)\n .map(([toolId, info]) => info.originalName);\n const msg = tools.length > 0 ? `Herramientas activas: ${tools.join(', ')}` : 'No hay herramientas registradas';\n ws.send(JSON.stringify({ id, type: 'toolResponse', result: { content: [{ type: 'text', text: msg }] } }));\n return;\n }\n\n if (todas) {\n let count = 0;\n for (const [toolId, info] of Object.entries(toolsRegistry)) {\n if (info.channel !== MCP_PATH) {\n delete toolsRegistry[toolId];\n count++;\n }\n }\n // Notify web clients\n for (const [channelPath, clients] of Object.entries(channels)) {\n if (channelPath === MCP_PATH) continue;\n clients.forEach(c => {\n if (c.readyState === WebSocket.OPEN) {\n c.send(JSON.stringify({ type: 'removeAllTools' }));\n }\n });\n }\n ws.send(JSON.stringify({ id, type: 'toolResponse', result: { content: [{ type: 'text', text: `${count} herramientas desregistradas` }] } }));\n return;\n }\n\n if (!name) {\n ws.send(JSON.stringify({ id, type: 'toolResponse', error: 'Especifica nombre, listar=true, o todas=true' }));\n return;\n }\n\n // Find and remove by originalName\n let found = false;\n for (const [toolId, info] of Object.entries(toolsRegistry)) {\n if (info.originalName === name) {\n const channel = info.channel;\n delete toolsRegistry[toolId];\n found = true;\n // Notify web client\n if (channels[channel]) {\n channels[channel].forEach(c => {\n if (c.readyState === WebSocket.OPEN) {\n c.send(JSON.stringify({ type: 'removeTool', name }));\n }\n });\n }\n break;\n }\n }\n\n if (found) {\n ws.send(JSON.stringify({ id, type: 'toolResponse', result: { content: [{ type: 'text', text: `Herramienta \"${name}\" desregistrada` }] } }));\n } else {\n ws.send(JSON.stringify({ id, type: 'toolResponse', error: `Herramienta \"${name}\" no encontrada` }));\n }\n}\n\n// Handle client info sent by browser on connect\nfunction handleClientInfo(ws, data) {\n const { userAgent, url, hostname, language, screenWidth, screenHeight, timestamp } = data;\n clientMetadata.set(ws, { userAgent, url, hostname, language, screenWidth, screenHeight, timestamp });\n console.error(`Client info stored for ${hostname}: ${url}`);\n}\n\n// Handle getClientInfo request - collect info from all connected browsers\nfunction handleGetClientInfo(ws, callerChannel, data) {\n const { id } = data;\n\n const clients = [];\n for (const [channelPath, channelClients] of Object.entries(channels)) {\n if (channelPath === MCP_PATH || channelPath === REGISTER_PATH) continue;\n for (const clientWs of channelClients) {\n const meta = clientMetadata.get(clientWs) || {};\n clients.push({\n channel: channelPath,\n userAgent: meta.userAgent || 'unknown',\n url: meta.url || 'unknown',\n hostname: meta.hostname || 'unknown',\n language: meta.language || 'unknown',\n screenWidth: meta.screenWidth || 0,\n screenHeight: meta.screenHeight || 0,\n connectedSince: meta.timestamp || 0\n });\n }\n }\n\n const text = clients.length > 0\n ? JSON.stringify(clients, null, 2)\n : 'No hay navegadores conectados';\n\n ws.send(JSON.stringify({\n id,\n type: 'toolResponse',\n result: { content: [{ type: 'text', text }] }\n }));\n}\n\n// Handle getServerInfo request - return server status and stats\nfunction handleGetServerInfo(ws, data) {\n const { id } = data;\n\n const uptimeMs = Date.now() - serverStartTime;\n const uptimeSec = Math.floor(uptimeMs / 1000);\n const hours = Math.floor(uptimeSec / 3600);\n const minutes = Math.floor((uptimeSec % 3600) / 60);\n const seconds = uptimeSec % 60;\n\n const channelsList = {};\n for (const [channelPath, channelClients] of Object.entries(channels)) {\n channelsList[channelPath] = channelClients.size;\n }\n\n const info = {\n server: `@nucleoriofrio/webmcp v0.2.0`,\n commit: gitCommit,\n host: HOST,\n port: CONFIG.port,\n dev: !!CONFIG.dev,\n uptime: `${hours}h ${minutes}m ${seconds}s`,\n uptimeMs,\n channels: channelsList,\n totalClients: Object.values(channels).reduce((sum, ch) => sum + ch.size, 0),\n registry: {\n tools: Object.keys(toolsRegistry).length,\n prompts: Object.keys(promptsRegistry).length,\n resources: Object.keys(resourcesRegistry).length,\n },\n toolsList: Object.entries(toolsRegistry).map(([id, info]) => ({\n id,\n name: info.originalName,\n channel: info.channel,\n })),\n pendingRequests: Object.keys(pendingRequests).length,\n };\n\n ws.send(JSON.stringify({\n id,\n type: 'toolResponse',\n result: { content: [{ type: 'text', text: JSON.stringify(info, null, 2) }] }\n }));\n}\n\n// Handle clearing all registries\nfunction handleClearRegistry(ws, data) {\n const {id} = data;\n let toolCount = Object.keys(toolsRegistry).length;\n let promptCount = Object.keys(promptsRegistry).length;\n let resourceCount = Object.keys(resourcesRegistry).length;\n\n for (const key of Object.keys(toolsRegistry)) delete toolsRegistry[key];\n for (const key of Object.keys(promptsRegistry)) delete promptsRegistry[key];\n for (const key of Object.keys(resourcesRegistry)) delete resourcesRegistry[key];\n\n const msg = `Cache limpiado: ${toolCount} tools, ${promptCount} prompts, ${resourceCount} resources eliminados`;\n console.error(msg);\n\n ws.send(JSON.stringify({\n id,\n type: 'toolResponse',\n result: msg\n }));\n}\n\n// Handle clipboard copy - broadcast to all non-MCP channels\nfunction handleClipboardCopy(data) {\n const {text} = data;\n if (!text) return;\n\n for (const [channelPath, channelClients] of Object.entries(channels)) {\n if (channelPath === MCP_PATH) continue;\n channelClients.forEach(client => {\n if (client.readyState === WebSocket.OPEN) {\n client.send(JSON.stringify({\n type: 'clipboardCopy',\n text\n }));\n }\n });\n }\n console.error(`Clipboard copy broadcasted to web clients`);\n}\n\n// Handle list tools requests\nfunction handleListTools(ws, clientChannel, data) {\n const {id} = data;\n\n // Special handling if the request is from the MCP client\n const isMcpClient = (clientChannel === MCP_PATH);\n\n let tools;\n\n if (isMcpClient) {\n // For MCP clients, return all tools across all paths with path prefixes\n tools = Object.entries(toolsRegistry).map(([toolId, toolInfo]) => {\n // Create a path-based fully qualified name - combine path and tool name\n const pathBasedName = `${toolInfo.channel.slice(1)}-${toolInfo.originalName}`;\n return {\n name: pathBasedName,\n description: toolInfo.description,\n inputSchema: toolInfo.inputSchema,\n };\n });\n console.error(`Sending all ${tools.length} tools to MCP client on path ${clientChannel}`);\n } else {\n // For regular clients, return only their own tools without path prefixes\n tools = Object.entries(toolsRegistry)\n .filter(([_, toolInfo]) => toolInfo.channel === clientChannel)\n .map(([_, toolInfo]) => ({\n name: toolInfo.originalName,\n description: toolInfo.description,\n inputSchema: toolInfo.inputSchema,\n }));\n console.error(`Sending ${tools.length} tools from path ${clientChannel}`);\n }\n\n ws.send(JSON.stringify({\n id,\n type: 'listToolsResponse',\n tools\n }));\n}\n\n// Handle list prompts requests\nfunction handleListPrompts(ws, clientChannel, data) {\n const {id} = data;\n\n // Special handling if the request is from the MCP client\n const isMcpClient = (clientChannel === MCP_PATH);\n\n let prompts;\n\n if (isMcpClient) {\n // For MCP clients, return all prompts across all paths with path prefixes\n prompts = Object.entries(promptsRegistry).map(([promptId, promptInfo]) => {\n // Create a path-based fully qualified name - combine path and prompt name\n const pathBasedName = `${promptInfo.channel.slice(1)}-${promptInfo.originalName}`;\n return {\n name: pathBasedName,\n description: promptInfo.description,\n arguments: promptInfo.arguments,\n };\n });\n console.error(`Sending all ${prompts.length} prompts to MCP client on path ${clientChannel}`);\n } else {\n // For regular clients, return only their own prompts without path prefixes\n prompts = Object.entries(promptsRegistry)\n .filter(([_, promptInfo]) => promptInfo.channel === clientChannel)\n .map(([_, promptInfo]) => ({\n name: promptInfo.originalName,\n description: promptInfo.description,\n arguments: promptInfo.arguments,\n }));\n console.error(`Sending ${prompts.length} prompts from path ${clientChannel}`);\n }\n\n ws.send(JSON.stringify({\n id,\n type: 'listPromptsResponse',\n prompts\n }));\n}\n\n// Handle list resources requests\nfunction handleListResources(ws, clientChannel, data) {\n const {id} = data;\n\n // Special handling if the request is from the MCP client\n const isMcpClient = (clientChannel === MCP_PATH);\n\n let resources = [];\n let resourceTemplates = [];\n\n if (isMcpClient) {\n // For MCP clients, return all resources across all paths with path prefixes\n Object.entries(resourcesRegistry).forEach(([resourceId, resourceInfo]) => {\n // Create a path-based fully qualified name - combine path and resource name\n const pathBasedName = `${resourceInfo.channel.slice(1)}-${resourceInfo.originalName}`;\n\n if (resourceInfo.isTemplate) {\n resourceTemplates.push({\n name: pathBasedName,\n description: resourceInfo.description,\n uriTemplate: resourceInfo.uriTemplate,\n mimeType: resourceInfo.mimeType,\n });\n } else {\n resources.push({\n name: pathBasedName,\n description: resourceInfo.description,\n uri: resourceInfo.uri,\n mimeType: resourceInfo.mimeType,\n });\n }\n });\n console.error(`Sending all ${resources.length} resources and ${resourceTemplates.length} templates to MCP client on path ${clientChannel}`);\n } else {\n // For regular clients, return only their own resources without path prefixes\n Object.entries(resourcesRegistry)\n .filter(([_, resourceInfo]) => resourceInfo.channel === clientChannel)\n .forEach(([_, resourceInfo]) => {\n if (resourceInfo.isTemplate) {\n resourceTemplates.push({\n name: resourceInfo.originalName,\n description: resourceInfo.description,\n uriTemplate: resourceInfo.uriTemplate,\n mimeType: resourceInfo.mimeType,\n });\n } else {\n resources.push({\n name: resourceInfo.originalName,\n description: resourceInfo.description,\n uri: resourceInfo.uri,\n mimeType: resourceInfo.mimeType,\n });\n }\n });\n console.error(`Sending ${resources.length} resources and ${resourceTemplates.length} templates from path ${clientChannel}`);\n }\n\n ws.send(JSON.stringify({\n id,\n type: 'listResourcesResponse',\n resources,\n resourceTemplates\n }));\n}\n\n// Handle tool call requests\nfunction handleCallTool(ws, callerChannel, data) {\n const {id, tool, arguments: args} = data;\n\n // Special handling if the caller is on the MCP path\n const isMcpClient = (callerChannel === MCP_PATH);\n\n // If the caller is MCP, the tool name might include a path prefix\n let targetChannel;\n let toolName;\n\n if (isMcpClient && tool.startsWith('/')) {\n // Extract the path and tool name from the fully qualified name\n [targetChannel, toolName] = tool.slice(1).split(\"-\").slice(1);\n targetChannel = `/${targetChannel}`;\n } else {\n // Check if the tool exists in the registry\n if (!toolsRegistry[tool]) {\n ws.send(JSON.stringify({\n id,\n type: 'toolResponse',\n error: `Tool not found: ${tool}`\n }));\n return;\n }\n\n const toolInfo = toolsRegistry[tool];\n targetChannel = toolInfo.channel;\n toolName = toolInfo.originalName;\n }\n\n // Get the target channel\n if (!channels[targetChannel] || channels[targetChannel].size === 0) {\n ws.send(JSON.stringify({\n id,\n type: 'toolResponse',\n error: `No clients available in channel ${targetChannel} to handle tool: ${toolName}`\n }));\n return;\n }\n\n // Pick the first client in the target channel (you could implement more sophisticated routing)\n const targetClient = channels[targetChannel].values().next().value;\n\n // Create a unique request ID for tracking\n const requestId = (requestIdCounter++).toString();\n\n // Store the pending request\n pendingRequests[requestId] = {\n originalId: id,\n requesterWs: ws,\n timestamp: Date.now()\n };\n\n // Set up timeout for the request\n setTimeout(() => {\n if (pendingRequests[requestId]) {\n const {requesterWs, originalId} = pendingRequests[requestId];\n delete pendingRequests[requestId];\n\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'toolResponse',\n error: `Tool call timed out: ${toolName}`\n }));\n } catch (error) {\n console.error('Error sending timeout response:', error);\n }\n }\n }, 30000); // 30 second timeout\n\n // Send the request to the target client\n targetClient.send(JSON.stringify({\n id: requestId,\n type: 'callTool',\n tool: toolName, // Send just the tool name without channel prefix\n arguments: args\n }));\n\n console.error(`Tool call forwarded: ${toolName} to channel: ${targetChannel}`);\n}\n\n// Handle get prompt requests\nfunction handleGetPrompt(ws, callerChannel, data) {\n const {id, name, arguments: args} = data;\n\n // Special handling if the caller is on the MCP path\n const isMcpClient = (callerChannel === MCP_PATH);\n\n // If the caller is MCP, the prompt name might include a path prefix\n let targetChannel;\n let promptName;\n\n if (isMcpClient && name.startsWith('/')) {\n // Extract the path and prompt name from the fully qualified name\n [targetChannel, promptName] = name.slice(1).split(\"-\").slice(1);\n targetChannel = `/${targetChannel}`;\n } else {\n // Check if the prompt exists in the registry\n const promptInfo = Object.values(promptsRegistry).find(p =>\n p.channel === callerChannel && p.originalName === name);\n\n if (!promptInfo) {\n ws.send(JSON.stringify({\n id,\n type: 'promptResponse',\n error: `Prompt not found: ${name}`\n }));\n return;\n }\n\n targetChannel = promptInfo.channel;\n promptName = promptInfo.originalName;\n }\n\n // Get the target channel\n if (!channels[targetChannel] || channels[targetChannel].size === 0) {\n ws.send(JSON.stringify({\n id,\n type: 'promptResponse',\n error: `No clients available in channel ${targetChannel} to handle prompt: ${promptName}`\n }));\n return;\n }\n\n // Pick the first client in the target channel\n const targetClient = channels[targetChannel].values().next().value;\n\n // Create a unique request ID for tracking\n const requestId = (requestIdCounter++).toString();\n\n // Store the pending request\n pendingRequests[requestId] = {\n originalId: id,\n requesterWs: ws,\n timestamp: Date.now()\n };\n\n // Set up timeout for the request\n setTimeout(() => {\n if (pendingRequests[requestId]) {\n const {requesterWs, originalId} = pendingRequests[requestId];\n delete pendingRequests[requestId];\n\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'promptResponse',\n error: `Prompt request timed out: ${promptName}`\n }));\n } catch (error) {\n console.error('Error sending timeout response:', error);\n }\n }\n }, 30000); // 30 second timeout\n\n // Send the request to the target client\n targetClient.send(JSON.stringify({\n id: requestId,\n type: 'getPrompt',\n name: promptName,\n arguments: args\n }));\n\n console.error(`Prompt request forwarded: ${promptName} to channel: ${targetChannel}`);\n}\n\n// Handle read resource requests\nfunction handleReadResource(ws, callerChannel, data) {\n const {id, uri} = data;\n\n // Find the resource that matches this URI\n let targetChannel;\n let resourceName;\n let resourceInfo;\n\n // First, try to find an exact match for the URI\n for (const [resId, info] of Object.entries(resourcesRegistry)) {\n if (!info.isTemplate && info.uri === uri) {\n resourceInfo = info;\n targetChannel = info.channel;\n resourceName = info.originalName;\n break;\n }\n }\n\n // If no exact match, check for templates\n if (!resourceInfo) {\n // This is a simplistic approach; a real implementation would properly parse the URI template\n for (const [resId, info] of Object.entries(resourcesRegistry)) {\n if (info.isTemplate && uri.startsWith(info.uriTemplate.split('{')[0])) {\n resourceInfo = info;\n targetChannel = info.channel;\n resourceName = info.originalName;\n break;\n }\n }\n }\n\n if (!resourceInfo) {\n ws.send(JSON.stringify({\n id,\n type: 'resourceResponse',\n error: `Resource not found for URI: ${uri}`\n }));\n return;\n }\n\n // Get the target channel\n if (!channels[targetChannel] || channels[targetChannel].size === 0) {\n ws.send(JSON.stringify({\n id,\n type: 'resourceResponse',\n error: `No clients available in channel ${targetChannel} to handle resource: ${resourceName}`\n }));\n return;\n }\n\n // Pick the first client in the target channel\n const targetClient = channels[targetChannel].values().next().value;\n\n // Create a unique request ID for tracking\n const requestId = (requestIdCounter++).toString();\n\n // Store the pending request\n pendingRequests[requestId] = {\n originalId: id,\n requesterWs: ws,\n timestamp: Date.now()\n };\n\n // Set up timeout for the request\n setTimeout(() => {\n if (pendingRequests[requestId]) {\n const {requesterWs, originalId} = pendingRequests[requestId];\n delete pendingRequests[requestId];\n\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'resourceResponse',\n error: `Resource request timed out: ${uri}`\n }));\n } catch (error) {\n console.error('Error sending timeout response:', error);\n }\n }\n }, 30000); // 30 second timeout\n\n // Send the request to the target client\n targetClient.send(JSON.stringify({\n id: requestId,\n type: 'readResource',\n uri: uri\n }));\n\n console.error(`Resource request forwarded: ${uri} to channel: ${targetChannel}`);\n}\n\n// Handle tool response\nfunction handleToolResponse(data) {\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (!pendingRequests[id]) {\n console.error(`No pending request found for ID: ${id}`);\n return;\n }\n\n // Get the original requester information\n const {requesterWs, originalId} = pendingRequests[id];\n delete pendingRequests[id];\n\n // Forward the response to the original requester\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'toolResponse',\n result: result,\n error: error\n }));\n } catch (error) {\n console.error('Error forwarding tool response:', error);\n }\n}\n\n// Handle prompt response\nfunction handlePromptResponse(data) {\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (!pendingRequests[id]) {\n console.error(`No pending request found for ID: ${id}`);\n return;\n }\n\n // Get the original requester information\n const {requesterWs, originalId} = pendingRequests[id];\n delete pendingRequests[id];\n\n // Forward the response to the original requester\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'promptResponse',\n result: result,\n error: error\n }));\n } catch (error) {\n console.error('Error forwarding prompt response:', error);\n }\n}\n\n// Handle resource response\nfunction handleResourceResponse(data) {\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (!pendingRequests[id]) {\n console.error(`No pending request found for ID: ${id}`);\n return;\n }\n\n // Get the original requester information\n const {requesterWs, originalId} = pendingRequests[id];\n delete pendingRequests[id];\n\n // Forward the response to the original requester\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'resourceResponse',\n result: result,\n error: error\n }));\n } catch (error) {\n console.error('Error forwarding resource response:', error);\n }\n}\n\n// Handle sampling response\nfunction handleSamplingResponse(data) {\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (!pendingRequests[id]) {\n console.error(`No pending request found for ID: ${id}`);\n return;\n }\n\n // Get the original requester information\n const {requesterWs, originalId} = pendingRequests[id];\n delete pendingRequests[id];\n\n // Forward the response to the original requester\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'samplingResponse',\n result: result,\n error: error\n }));\n } catch (error) {\n console.error('Error forwarding sampling response:', error);\n }\n}\n\n// Handle create sampling message\nfunction handleCreateSamplingMessage(ws, callerChannel, data) {\n const {\n id,\n messages,\n systemPrompt,\n includeContext,\n temperature,\n maxTokens,\n stopSequences,\n metadata,\n modelPreferences\n } = data;\n\n // Special handling if the caller is on the MCP path\n const isMcpClient = (callerChannel === MCP_PATH);\n\n // For non-MCP clients or if no client is available in any channel\n if (!isMcpClient) {\n ws.send(JSON.stringify({\n id,\n type: 'samplingResponse',\n error: `Sampling is only available through MCP path`\n }));\n return;\n }\n\n // Find a client that can handle sampling - target the first available client\n let targetClient = null;\n let targetChannel = null;\n\n // Iterate through all channels to find one with clients\n for (const [channel, clients] of Object.entries(channels)) {\n if (channel !== MCP_PATH && clients.size > 0) {\n targetClient = clients.values().next().value;\n targetChannel = channel;\n break;\n }\n }\n\n if (!targetClient) {\n ws.send(JSON.stringify({\n id,\n type: 'samplingResponse',\n error: 'No clients available to handle sampling request'\n }));\n return;\n }\n\n // Create a unique request ID for tracking\n const requestId = (requestIdCounter++).toString();\n\n // Store the pending request\n pendingRequests[requestId] = {\n originalId: id,\n requesterWs: ws,\n timestamp: Date.now()\n };\n\n // Set up timeout for the request (longer timeout for sampling)\n setTimeout(() => {\n if (pendingRequests[requestId]) {\n const {requesterWs, originalId} = pendingRequests[requestId];\n delete pendingRequests[requestId];\n\n try {\n requesterWs.send(JSON.stringify({\n id: originalId,\n type: 'samplingResponse',\n error: 'Sampling request timed out'\n }));\n } catch (error) {\n console.error('Error sending timeout response:', error);\n }\n }\n }, 120000); // 120 second timeout for sampling\n\n // Forward the request to the target client\n targetClient.send(JSON.stringify({\n id: requestId,\n type: 'createSamplingMessage',\n messages,\n systemPrompt,\n includeContext,\n temperature,\n maxTokens,\n stopSequences,\n metadata,\n modelPreferences\n }));\n\n console.error(`Sampling request forwarded to channel: ${targetChannel}`);\n}\n\n\n// Function to decode a base64 encoded channel-token pair\nfunction decodeChannelTokenPair(encodedPair) {\n try {\n const decodedString = Buffer.from(encodedPair, 'base64').toString('utf8');\n const [channel, token] = decodedString.split(':');\n\n if (!channel || !token) {\n throw new Error('Invalid format');\n }\n\n // Ensure channel has leading slash\n const formattedChannel = channel.startsWith('/') ? channel : `/${channel}`;\n\n return {channel: formattedChannel, token};\n } catch (error) {\n console.error('Error decoding channel-token pair:', error);\n return null;\n }\n}\n\n// Function to authorize a new channel-token pair\nasync function authorizeChannelToken(encodedPair) {\n const decoded = decodeChannelTokenPair(encodedPair);\n if (!decoded) {\n return {success: false, message: 'Invalid encoded channel-token pair'};\n }\n\n const {channel, token} = decoded;\n\n // Check if this channel already has an active connection\n if (channels[channel] && channels[channel].size > 0) {\n return {success: false, message: `Channel ${channel} already has an active connection`};\n }\n\n // Add to authorized tokens\n setToken(channel, token);\n await saveAuthorizedTokens();\n\n return {\n success: true,\n message: `Authorized channel: ${channel}`,\n channel,\n token\n };\n}\n\n// Function to check if server is already running\nasync function isServerRunning() {\n // If using \"docker\" and \"startMCP\" just assume the server is running\n if (CONFIG.startMCP && CONFIG.docker) {\n return true;\n }\n\n try {\n // Check if PID file exists\n const pidData = await fs.readFile(PID_FILE, 'utf8');\n const pid = parseInt(pidData.trim(), 10);\n\n // Check if process with this PID is running\n // This is platform-specific, using a simple approach\n try {\n process.kill(pid, 0); // This doesn't actually kill the process, just checks if it exists\n return {running: true, pid};\n } catch (e) {\n // Process not running, remove stale PID file\n await fs.unlink(PID_FILE);\n return {running: false};\n }\n } catch (error) {\n // PID file doesn't exist or other error\n return {running: false};\n }\n}\n\n// Function to save current PID to file\nasync function savePid() {\n try {\n await fs.writeFile(PID_FILE, process.pid.toString(), 'utf8');\n return true;\n } catch (error) {\n console.error('Error saving PID file:', error);\n return false;\n }\n}\n\n// Function to run the server in the background\nasync function daemonize() {\n // Fork a new process that will become the daemon\n const args = process.argv.slice(2);\n\n // Make sure the --forked flag is included\n if (!args.includes('--forked')) {\n args.push('--forked');\n }\n\n // Create a detached child process\n const child = fork(process.argv[1], args, {\n detached: true,\n stdio: 'ignore'\n });\n\n // Detach the child process so it can run independently\n child.unref();\n\n console.error(`Server started as daemon with PID: ${child.pid}`);\n console.error(`Use 'node websocket-server.js --quit' to stop the server`);\n console.error(`Use 'node websocket-server.js --new ' to authorize a channel-token pair`);\n console.error(`Put 'npx @nucleoriofrio/webmcp --mcp' in your mcp client config`);\n if (!CONFIG.startMCP) {\n process.exit(0);\n }\n}\n\nconst parseArgs = async () => {\n const args = process.argv.slice(2);\n let port = 4797; // Default port\n let quit = false;\n let newToken = false;\n let startMCP = false;\n let docker = false;\n let cleanTokens = false;\n let encodedPair = null;\n let daemon = true; // Default to daemonize\n let dev = process.env.WEBMCP_DEV === 'true' || process.env.WEBMCP_DEV === '1';\n\n for (let i = 0; i < args.length; i++) {\n const arg = args[i];\n\n if (arg === '-h' || arg === '--help') {\n showHelp();\n process.exit(0);\n } else if (arg === '-p' || arg === '--port') {\n if (i + 1 < args.length) {\n const portArg = parseInt(args[i + 1], 10);\n if (isNaN(portArg) || portArg < 1 || portArg > 65535) {\n console.error('Error: Port must be a number between 1 and 65535');\n showHelp();\n process.exit(1);\n }\n port = portArg;\n i++; // Skip the next argument as we've already processed it\n } else {\n console.error('Error: Port option requires a value');\n showHelp();\n process.exit(1);\n }\n } else if (arg === '--config') {\n if (i + 1 < args.length) {\n const config = args[i + 1];\n await configureMcpClient(config)\n i++; // Skip the next argument as we've already processed it\n } else {\n console.error('Error: Config option requires a mcp client type or path to json');\n showHelp();\n process.exit(1);\n }\n } else if (arg === '-q' || arg === '--quit') {\n quit = true;\n } else if (arg === '-n' || arg === '--new') {\n newToken = true;\n } else if (arg === '-m' || arg === '--mcp') {\n startMCP = true;\n } else if (arg === '-d' || arg === '--docker') {\n docker = true;\n } else if (arg === '-c' || arg === '--clean') {\n cleanTokens = true;\n } else if (arg === '-f' || arg === '--foreground') {\n daemon = false;\n } else if (arg === '--dev') {\n dev = true;\n } else if (arg === '--forked') {\n // This is an internal flag to indicate we're the forked child \u2502 \u2502\n // No need to do anything with it here, just don't error on it\n } else {\n console.error(`Error: Unknown option: ${arg}`);\n showHelp();\n process.exit(1);\n }\n }\n\n return {port, quit, newToken, cleanTokens, encodedPair, daemon, startMCP, dev};\n};\n\nconst showHelp = () => {\n console.log(`\nUsage: node websocket-server.js [options]\n\nOptions:\n --config Automatically update MCP client configuration to add WebMCP\n -p, --port Specify the port number (default: 4797)\n -h, --help Display this help message\n -q, --quit Stop the running server\n -n, --new Generate a new token for client registration\n -c, --clean Remove all authorized tokens\n -f, --foreground Run in foreground (don't daemonize)\n -m, --mcp Internal WebMCP Server codepath, likely only used in MCP client config\n -d, --docker Tell the MCP client that WebMCP is running in docker\n --dev Enable development mode (agregar-tool, quitar-tool)\n\nUse --new to generate a token which clients can use to register on the /register endpoint.\nUse --clean to remove all authorized tokens when you want to start fresh.\n `);\n};\n\nconst main = async () => {\n // Ensure the config directory exists\n await ensureConfigDir();\n\n // Load authorized tokens from disk\n await loadAuthorizedTokens();\n\n setConfig(await parseArgs());\n\n // Check if server is already running\n const serverStatus = await isServerRunning();\n\n // Handle clean tokens command\n if (CONFIG.cleanTokens) {\n console.log(`Removing all authorized tokens...`);\n clearTokens();\n await saveAuthorizedTokens();\n console.log(`All tokens have been removed. Tokens file cleared.`);\n\n // If server is running, we need to notify it to reload tokens\n if (serverStatus.running) {\n console.log(`Server is running with PID: ${serverStatus.pid}. Please restart it to apply changes.`);\n }\n\n process.exit(0);\n }\n\n // Handle quit command\n if (CONFIG.quit) {\n if (serverStatus.running) {\n console.log(`Stopping server with PID: ${serverStatus.pid}`);\n try {\n process.kill(serverStatus.pid, 'SIGTERM');\n console.log('Server stopped successfully');\n } catch (error) {\n console.error('Error stopping server:', error);\n }\n } else {\n console.log('No running server found');\n }\n process.exit(0);\n }\n\n // Handle new token generation\n if (CONFIG.newToken) {\n const encodedData = await generateNewRegistrationToken();\n console.log(`\\nCONNECTION TOKEN (paste this in your web client):`);\n console.log(`${encodedData}\\n`);\n\n // If server is running, exit\n if (serverStatus.running) {\n process.exit(0);\n }\n }\n\n // Check if we have a server token, generate one if not\n if (!serverToken) {\n // console.log('No server token found, generating a new one...');\n serverToken = generateToken();\n await saveServerTokenToEnv(serverToken);\n // console.log(`New server token: \"${serverToken}\". Saved to .env`);\n }\n\n // If server is already running and we're not authorizing a token, just show status and exit\n if (serverStatus.running) {\n console.error(`Server is already running with PID: ${serverStatus.pid}`);\n console.error(`Use 'node websocket-server.js --quit' to stop the server`);\n console.error(`Use 'node websocket-server.js --new ' to authorize a channel-token pair`);\n console.error(`Put 'npx @nucleoriofrio/webmcp --mcp' in your mcp client config`);\n if (CONFIG.startMCP) {\n return;\n } else {\n process.exit(0);\n }\n }\n\n // Daemonize if requested\n if (CONFIG.daemon) {\n // We need to add a marker to args to prevent fork bombs\n // If we already have the --forked flag, we're in the child process and should continue\n if (!process.argv.includes('--forked')) {\n // Add the --forked flag to the arguments before daemonizing\n process.argv.push('--forked');\n return daemonize();\n }\n }\n\n // If we have the --forked flag, we're already the daemon, continue execution\n // Save PID file\n await savePid();\n\n // Start the server\n const PORT = CONFIG.port;\n httpServer.listen(PORT, () => {\n console.error(`@nucleoriofrio/webmcp v0.2.0 \u2014 WebSocket server running at http://${HOST}:${PORT}`);\n console.error(`WebMCP client token (for MCP path): ${serverToken}`);\n console.error(`WebMCP client URL: ws://${HOST}:${PORT}${MCP_PATH}?token=${serverToken}`);\n if (CONFIG.dev) {\n console.error(`[DEV] Modo desarrollo activo \u2014 agregar-tool y quitar-tool habilitados`);\n }\n console.error(`Use 'node websocket-server.js --new ' to authorize a channel-token pair`);\n });\n\n // Handle graceful shutdown\n const shutdownGracefully = async (signal) => {\n console.error(`\\nReceived ${signal}. Shutting down gracefully...`);\n\n // Save authorized tokens before shutting down\n await saveAuthorizedTokens();\n\n // Close all WebSocket connections in all channels\n for (const channel of Object.values(channels)) {\n for (const ws of channel) {\n try {\n ws.close();\n } catch (error) {\n console.error('Error closing WebSocket connection:', error);\n }\n }\n }\n\n // Close the HTTP server\n httpServer.close(() => {\n console.error('HTTP server closed');\n\n // Remove PID file\n fs.unlink(PID_FILE).catch(err => {\n console.error('Error removing PID file:', err);\n });\n\n process.exit(0);\n });\n };\n\n // Handle CTRL+C (SIGINT)\n process.on('SIGINT', () => shutdownGracefully('SIGINT'));\n\n // Handle SIGTERM\n process.on('SIGTERM', () => shutdownGracefully('SIGTERM'));\n\n // Enable keyboard input handling for CTRL+C on Windows\n if (process.platform === 'win32' && process.stdin.isTTY) {\n try {\n process.stdin.setRawMode(true);\n process.stdin.resume();\n process.stdin.on('data', (data) => {\n // Check for CTRL+C (03 in hex)\n if (data.length === 1 && data[0] === 0x03) {\n shutdownGracefully('CTRL+C');\n }\n });\n } catch (e) {\n // stdin not available, ignore\n }\n }\n};\n\nmain().catch(error => {\n console.error('Error in main:', error);\n process.exit(1);\n}).then(() => {\n // Handle starting MCP\n if (CONFIG.startMCP) {\n setTimeout(() => {\n console.error(\"Starting up MCP Server\")\n runMcpServer(serverToken).catch((error) => {\n console.error(\"Fatal error in main():\", error);\n process.exit(1);\n });\n }, 100);\n }\n});\n", "import createWebSocketStream from './lib/stream.js';\nimport Receiver from './lib/receiver.js';\nimport Sender from './lib/sender.js';\nimport WebSocket from './lib/websocket.js';\nimport WebSocketServer from './lib/websocket-server.js';\n\nexport { createWebSocketStream, Receiver, Sender, WebSocket, WebSocketServer };\nexport default WebSocket;\n", "export var util;\n(function (util) {\n util.assertEqual = (_) => { };\n function assertIs(_arg) { }\n util.assertIs = assertIs;\n function assertNever(_x) {\n throw new Error();\n }\n util.assertNever = assertNever;\n util.arrayToEnum = (items) => {\n const obj = {};\n for (const item of items) {\n obj[item] = item;\n }\n return obj;\n };\n util.getValidEnumValues = (obj) => {\n const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== \"number\");\n const filtered = {};\n for (const k of validKeys) {\n filtered[k] = obj[k];\n }\n return util.objectValues(filtered);\n };\n util.objectValues = (obj) => {\n return util.objectKeys(obj).map(function (e) {\n return obj[e];\n });\n };\n util.objectKeys = typeof Object.keys === \"function\" // eslint-disable-line ban/ban\n ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban\n : (object) => {\n const keys = [];\n for (const key in object) {\n if (Object.prototype.hasOwnProperty.call(object, key)) {\n keys.push(key);\n }\n }\n return keys;\n };\n util.find = (arr, checker) => {\n for (const item of arr) {\n if (checker(item))\n return item;\n }\n return undefined;\n };\n util.isInteger = typeof Number.isInteger === \"function\"\n ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban\n : (val) => typeof val === \"number\" && Number.isFinite(val) && Math.floor(val) === val;\n function joinValues(array, separator = \" | \") {\n return array.map((val) => (typeof val === \"string\" ? `'${val}'` : val)).join(separator);\n }\n util.joinValues = joinValues;\n util.jsonStringifyReplacer = (_, value) => {\n if (typeof value === \"bigint\") {\n return value.toString();\n }\n return value;\n };\n})(util || (util = {}));\nexport var objectUtil;\n(function (objectUtil) {\n objectUtil.mergeShapes = (first, second) => {\n return {\n ...first,\n ...second, // second overwrites first\n };\n };\n})(objectUtil || (objectUtil = {}));\nexport const ZodParsedType = util.arrayToEnum([\n \"string\",\n \"nan\",\n \"number\",\n \"integer\",\n \"float\",\n \"boolean\",\n \"date\",\n \"bigint\",\n \"symbol\",\n \"function\",\n \"undefined\",\n \"null\",\n \"array\",\n \"object\",\n \"unknown\",\n \"promise\",\n \"void\",\n \"never\",\n \"map\",\n \"set\",\n]);\nexport const getParsedType = (data) => {\n const t = typeof data;\n switch (t) {\n case \"undefined\":\n return ZodParsedType.undefined;\n case \"string\":\n return ZodParsedType.string;\n case \"number\":\n return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;\n case \"boolean\":\n return ZodParsedType.boolean;\n case \"function\":\n return ZodParsedType.function;\n case \"bigint\":\n return ZodParsedType.bigint;\n case \"symbol\":\n return ZodParsedType.symbol;\n case \"object\":\n if (Array.isArray(data)) {\n return ZodParsedType.array;\n }\n if (data === null) {\n return ZodParsedType.null;\n }\n if (data.then && typeof data.then === \"function\" && data.catch && typeof data.catch === \"function\") {\n return ZodParsedType.promise;\n }\n if (typeof Map !== \"undefined\" && data instanceof Map) {\n return ZodParsedType.map;\n }\n if (typeof Set !== \"undefined\" && data instanceof Set) {\n return ZodParsedType.set;\n }\n if (typeof Date !== \"undefined\" && data instanceof Date) {\n return ZodParsedType.date;\n }\n return ZodParsedType.object;\n default:\n return ZodParsedType.unknown;\n }\n};\n", "import { util } from \"./helpers/util.js\";\nexport const ZodIssueCode = util.arrayToEnum([\n \"invalid_type\",\n \"invalid_literal\",\n \"custom\",\n \"invalid_union\",\n \"invalid_union_discriminator\",\n \"invalid_enum_value\",\n \"unrecognized_keys\",\n \"invalid_arguments\",\n \"invalid_return_type\",\n \"invalid_date\",\n \"invalid_string\",\n \"too_small\",\n \"too_big\",\n \"invalid_intersection_types\",\n \"not_multiple_of\",\n \"not_finite\",\n]);\nexport const quotelessJson = (obj) => {\n const json = JSON.stringify(obj, null, 2);\n return json.replace(/\"([^\"]+)\":/g, \"$1:\");\n};\nexport class ZodError extends Error {\n get errors() {\n return this.issues;\n }\n constructor(issues) {\n super();\n this.issues = [];\n this.addIssue = (sub) => {\n this.issues = [...this.issues, sub];\n };\n this.addIssues = (subs = []) => {\n this.issues = [...this.issues, ...subs];\n };\n const actualProto = new.target.prototype;\n if (Object.setPrototypeOf) {\n // eslint-disable-next-line ban/ban\n Object.setPrototypeOf(this, actualProto);\n }\n else {\n this.__proto__ = actualProto;\n }\n this.name = \"ZodError\";\n this.issues = issues;\n }\n format(_mapper) {\n const mapper = _mapper ||\n function (issue) {\n return issue.message;\n };\n const fieldErrors = { _errors: [] };\n const processError = (error) => {\n for (const issue of error.issues) {\n if (issue.code === \"invalid_union\") {\n issue.unionErrors.map(processError);\n }\n else if (issue.code === \"invalid_return_type\") {\n processError(issue.returnTypeError);\n }\n else if (issue.code === \"invalid_arguments\") {\n processError(issue.argumentsError);\n }\n else if (issue.path.length === 0) {\n fieldErrors._errors.push(mapper(issue));\n }\n else {\n let curr = fieldErrors;\n let i = 0;\n while (i < issue.path.length) {\n const el = issue.path[i];\n const terminal = i === issue.path.length - 1;\n if (!terminal) {\n curr[el] = curr[el] || { _errors: [] };\n // if (typeof el === \"string\") {\n // curr[el] = curr[el] || { _errors: [] };\n // } else if (typeof el === \"number\") {\n // const errorArray: any = [];\n // errorArray._errors = [];\n // curr[el] = curr[el] || errorArray;\n // }\n }\n else {\n curr[el] = curr[el] || { _errors: [] };\n curr[el]._errors.push(mapper(issue));\n }\n curr = curr[el];\n i++;\n }\n }\n }\n };\n processError(this);\n return fieldErrors;\n }\n static assert(value) {\n if (!(value instanceof ZodError)) {\n throw new Error(`Not a ZodError: ${value}`);\n }\n }\n toString() {\n return this.message;\n }\n get message() {\n return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);\n }\n get isEmpty() {\n return this.issues.length === 0;\n }\n flatten(mapper = (issue) => issue.message) {\n const fieldErrors = Object.create(null);\n const formErrors = [];\n for (const sub of this.issues) {\n if (sub.path.length > 0) {\n const firstEl = sub.path[0];\n fieldErrors[firstEl] = fieldErrors[firstEl] || [];\n fieldErrors[firstEl].push(mapper(sub));\n }\n else {\n formErrors.push(mapper(sub));\n }\n }\n return { formErrors, fieldErrors };\n }\n get formErrors() {\n return this.flatten();\n }\n}\nZodError.create = (issues) => {\n const error = new ZodError(issues);\n return error;\n};\n", "import { ZodIssueCode } from \"../ZodError.js\";\nimport { util, ZodParsedType } from \"../helpers/util.js\";\nconst errorMap = (issue, _ctx) => {\n let message;\n switch (issue.code) {\n case ZodIssueCode.invalid_type:\n if (issue.received === ZodParsedType.undefined) {\n message = \"Required\";\n }\n else {\n message = `Expected ${issue.expected}, received ${issue.received}`;\n }\n break;\n case ZodIssueCode.invalid_literal:\n message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;\n break;\n case ZodIssueCode.unrecognized_keys:\n message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, \", \")}`;\n break;\n case ZodIssueCode.invalid_union:\n message = `Invalid input`;\n break;\n case ZodIssueCode.invalid_union_discriminator:\n message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;\n break;\n case ZodIssueCode.invalid_enum_value:\n message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;\n break;\n case ZodIssueCode.invalid_arguments:\n message = `Invalid function arguments`;\n break;\n case ZodIssueCode.invalid_return_type:\n message = `Invalid function return type`;\n break;\n case ZodIssueCode.invalid_date:\n message = `Invalid date`;\n break;\n case ZodIssueCode.invalid_string:\n if (typeof issue.validation === \"object\") {\n if (\"includes\" in issue.validation) {\n message = `Invalid input: must include \"${issue.validation.includes}\"`;\n if (typeof issue.validation.position === \"number\") {\n message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;\n }\n }\n else if (\"startsWith\" in issue.validation) {\n message = `Invalid input: must start with \"${issue.validation.startsWith}\"`;\n }\n else if (\"endsWith\" in issue.validation) {\n message = `Invalid input: must end with \"${issue.validation.endsWith}\"`;\n }\n else {\n util.assertNever(issue.validation);\n }\n }\n else if (issue.validation !== \"regex\") {\n message = `Invalid ${issue.validation}`;\n }\n else {\n message = \"Invalid\";\n }\n break;\n case ZodIssueCode.too_small:\n if (issue.type === \"array\")\n message = `Array must contain ${issue.exact ? \"exactly\" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;\n else if (issue.type === \"string\")\n message = `String must contain ${issue.exact ? \"exactly\" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;\n else if (issue.type === \"number\")\n message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;\n else if (issue.type === \"bigint\")\n message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;\n else if (issue.type === \"date\")\n message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;\n else\n message = \"Invalid input\";\n break;\n case ZodIssueCode.too_big:\n if (issue.type === \"array\")\n message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;\n else if (issue.type === \"string\")\n message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;\n else if (issue.type === \"number\")\n message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;\n else if (issue.type === \"bigint\")\n message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;\n else if (issue.type === \"date\")\n message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;\n else\n message = \"Invalid input\";\n break;\n case ZodIssueCode.custom:\n message = `Invalid input`;\n break;\n case ZodIssueCode.invalid_intersection_types:\n message = `Intersection results could not be merged`;\n break;\n case ZodIssueCode.not_multiple_of:\n message = `Number must be a multiple of ${issue.multipleOf}`;\n break;\n case ZodIssueCode.not_finite:\n message = \"Number must be finite\";\n break;\n default:\n message = _ctx.defaultError;\n util.assertNever(issue);\n }\n return { message };\n};\nexport default errorMap;\n", "import defaultErrorMap from \"./locales/en.js\";\nlet overrideErrorMap = defaultErrorMap;\nexport { defaultErrorMap };\nexport function setErrorMap(map) {\n overrideErrorMap = map;\n}\nexport function getErrorMap() {\n return overrideErrorMap;\n}\n", "import { getErrorMap } from \"../errors.js\";\nimport defaultErrorMap from \"../locales/en.js\";\nexport const makeIssue = (params) => {\n const { data, path, errorMaps, issueData } = params;\n const fullPath = [...path, ...(issueData.path || [])];\n const fullIssue = {\n ...issueData,\n path: fullPath,\n };\n if (issueData.message !== undefined) {\n return {\n ...issueData,\n path: fullPath,\n message: issueData.message,\n };\n }\n let errorMessage = \"\";\n const maps = errorMaps\n .filter((m) => !!m)\n .slice()\n .reverse();\n for (const map of maps) {\n errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;\n }\n return {\n ...issueData,\n path: fullPath,\n message: errorMessage,\n };\n};\nexport const EMPTY_PATH = [];\nexport function addIssueToContext(ctx, issueData) {\n const overrideMap = getErrorMap();\n const issue = makeIssue({\n issueData: issueData,\n data: ctx.data,\n path: ctx.path,\n errorMaps: [\n ctx.common.contextualErrorMap, // contextual error map is first priority\n ctx.schemaErrorMap, // then schema-bound map if available\n overrideMap, // then global override map\n overrideMap === defaultErrorMap ? undefined : defaultErrorMap, // then global default map\n ].filter((x) => !!x),\n });\n ctx.common.issues.push(issue);\n}\nexport class ParseStatus {\n constructor() {\n this.value = \"valid\";\n }\n dirty() {\n if (this.value === \"valid\")\n this.value = \"dirty\";\n }\n abort() {\n if (this.value !== \"aborted\")\n this.value = \"aborted\";\n }\n static mergeArray(status, results) {\n const arrayValue = [];\n for (const s of results) {\n if (s.status === \"aborted\")\n return INVALID;\n if (s.status === \"dirty\")\n status.dirty();\n arrayValue.push(s.value);\n }\n return { status: status.value, value: arrayValue };\n }\n static async mergeObjectAsync(status, pairs) {\n const syncPairs = [];\n for (const pair of pairs) {\n const key = await pair.key;\n const value = await pair.value;\n syncPairs.push({\n key,\n value,\n });\n }\n return ParseStatus.mergeObjectSync(status, syncPairs);\n }\n static mergeObjectSync(status, pairs) {\n const finalObject = {};\n for (const pair of pairs) {\n const { key, value } = pair;\n if (key.status === \"aborted\")\n return INVALID;\n if (value.status === \"aborted\")\n return INVALID;\n if (key.status === \"dirty\")\n status.dirty();\n if (value.status === \"dirty\")\n status.dirty();\n if (key.value !== \"__proto__\" && (typeof value.value !== \"undefined\" || pair.alwaysSet)) {\n finalObject[key.value] = value.value;\n }\n }\n return { status: status.value, value: finalObject };\n }\n}\nexport const INVALID = Object.freeze({\n status: \"aborted\",\n});\nexport const DIRTY = (value) => ({ status: \"dirty\", value });\nexport const OK = (value) => ({ status: \"valid\", value });\nexport const isAborted = (x) => x.status === \"aborted\";\nexport const isDirty = (x) => x.status === \"dirty\";\nexport const isValid = (x) => x.status === \"valid\";\nexport const isAsync = (x) => typeof Promise !== \"undefined\" && x instanceof Promise;\n", "export var errorUtil;\n(function (errorUtil) {\n errorUtil.errToObj = (message) => typeof message === \"string\" ? { message } : message || {};\n // biome-ignore lint:\n errorUtil.toString = (message) => typeof message === \"string\" ? message : message?.message;\n})(errorUtil || (errorUtil = {}));\n", "import { ZodError, ZodIssueCode, } from \"./ZodError.js\";\nimport { defaultErrorMap, getErrorMap } from \"./errors.js\";\nimport { errorUtil } from \"./helpers/errorUtil.js\";\nimport { DIRTY, INVALID, OK, ParseStatus, addIssueToContext, isAborted, isAsync, isDirty, isValid, makeIssue, } from \"./helpers/parseUtil.js\";\nimport { util, ZodParsedType, getParsedType } from \"./helpers/util.js\";\nclass ParseInputLazyPath {\n constructor(parent, value, path, key) {\n this._cachedPath = [];\n this.parent = parent;\n this.data = value;\n this._path = path;\n this._key = key;\n }\n get path() {\n if (!this._cachedPath.length) {\n if (Array.isArray(this._key)) {\n this._cachedPath.push(...this._path, ...this._key);\n }\n else {\n this._cachedPath.push(...this._path, this._key);\n }\n }\n return this._cachedPath;\n }\n}\nconst handleResult = (ctx, result) => {\n if (isValid(result)) {\n return { success: true, data: result.value };\n }\n else {\n if (!ctx.common.issues.length) {\n throw new Error(\"Validation failed but no issues detected.\");\n }\n return {\n success: false,\n get error() {\n if (this._error)\n return this._error;\n const error = new ZodError(ctx.common.issues);\n this._error = error;\n return this._error;\n },\n };\n }\n};\nfunction processCreateParams(params) {\n if (!params)\n return {};\n const { errorMap, invalid_type_error, required_error, description } = params;\n if (errorMap && (invalid_type_error || required_error)) {\n throw new Error(`Can't use \"invalid_type_error\" or \"required_error\" in conjunction with custom error map.`);\n }\n if (errorMap)\n return { errorMap: errorMap, description };\n const customMap = (iss, ctx) => {\n const { message } = params;\n if (iss.code === \"invalid_enum_value\") {\n return { message: message ?? ctx.defaultError };\n }\n if (typeof ctx.data === \"undefined\") {\n return { message: message ?? required_error ?? ctx.defaultError };\n }\n if (iss.code !== \"invalid_type\")\n return { message: ctx.defaultError };\n return { message: message ?? invalid_type_error ?? ctx.defaultError };\n };\n return { errorMap: customMap, description };\n}\nexport class ZodType {\n get description() {\n return this._def.description;\n }\n _getType(input) {\n return getParsedType(input.data);\n }\n _getOrReturnCtx(input, ctx) {\n return (ctx || {\n common: input.parent.common,\n data: input.data,\n parsedType: getParsedType(input.data),\n schemaErrorMap: this._def.errorMap,\n path: input.path,\n parent: input.parent,\n });\n }\n _processInputParams(input) {\n return {\n status: new ParseStatus(),\n ctx: {\n common: input.parent.common,\n data: input.data,\n parsedType: getParsedType(input.data),\n schemaErrorMap: this._def.errorMap,\n path: input.path,\n parent: input.parent,\n },\n };\n }\n _parseSync(input) {\n const result = this._parse(input);\n if (isAsync(result)) {\n throw new Error(\"Synchronous parse encountered promise.\");\n }\n return result;\n }\n _parseAsync(input) {\n const result = this._parse(input);\n return Promise.resolve(result);\n }\n parse(data, params) {\n const result = this.safeParse(data, params);\n if (result.success)\n return result.data;\n throw result.error;\n }\n safeParse(data, params) {\n const ctx = {\n common: {\n issues: [],\n async: params?.async ?? false,\n contextualErrorMap: params?.errorMap,\n },\n path: params?.path || [],\n schemaErrorMap: this._def.errorMap,\n parent: null,\n data,\n parsedType: getParsedType(data),\n };\n const result = this._parseSync({ data, path: ctx.path, parent: ctx });\n return handleResult(ctx, result);\n }\n \"~validate\"(data) {\n const ctx = {\n common: {\n issues: [],\n async: !!this[\"~standard\"].async,\n },\n path: [],\n schemaErrorMap: this._def.errorMap,\n parent: null,\n data,\n parsedType: getParsedType(data),\n };\n if (!this[\"~standard\"].async) {\n try {\n const result = this._parseSync({ data, path: [], parent: ctx });\n return isValid(result)\n ? {\n value: result.value,\n }\n : {\n issues: ctx.common.issues,\n };\n }\n catch (err) {\n if (err?.message?.toLowerCase()?.includes(\"encountered\")) {\n this[\"~standard\"].async = true;\n }\n ctx.common = {\n issues: [],\n async: true,\n };\n }\n }\n return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result)\n ? {\n value: result.value,\n }\n : {\n issues: ctx.common.issues,\n });\n }\n async parseAsync(data, params) {\n const result = await this.safeParseAsync(data, params);\n if (result.success)\n return result.data;\n throw result.error;\n }\n async safeParseAsync(data, params) {\n const ctx = {\n common: {\n issues: [],\n contextualErrorMap: params?.errorMap,\n async: true,\n },\n path: params?.path || [],\n schemaErrorMap: this._def.errorMap,\n parent: null,\n data,\n parsedType: getParsedType(data),\n };\n const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });\n const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));\n return handleResult(ctx, result);\n }\n refine(check, message) {\n const getIssueProperties = (val) => {\n if (typeof message === \"string\" || typeof message === \"undefined\") {\n return { message };\n }\n else if (typeof message === \"function\") {\n return message(val);\n }\n else {\n return message;\n }\n };\n return this._refinement((val, ctx) => {\n const result = check(val);\n const setError = () => ctx.addIssue({\n code: ZodIssueCode.custom,\n ...getIssueProperties(val),\n });\n if (typeof Promise !== \"undefined\" && result instanceof Promise) {\n return result.then((data) => {\n if (!data) {\n setError();\n return false;\n }\n else {\n return true;\n }\n });\n }\n if (!result) {\n setError();\n return false;\n }\n else {\n return true;\n }\n });\n }\n refinement(check, refinementData) {\n return this._refinement((val, ctx) => {\n if (!check(val)) {\n ctx.addIssue(typeof refinementData === \"function\" ? refinementData(val, ctx) : refinementData);\n return false;\n }\n else {\n return true;\n }\n });\n }\n _refinement(refinement) {\n return new ZodEffects({\n schema: this,\n typeName: ZodFirstPartyTypeKind.ZodEffects,\n effect: { type: \"refinement\", refinement },\n });\n }\n superRefine(refinement) {\n return this._refinement(refinement);\n }\n constructor(def) {\n /** Alias of safeParseAsync */\n this.spa = this.safeParseAsync;\n this._def = def;\n this.parse = this.parse.bind(this);\n this.safeParse = this.safeParse.bind(this);\n this.parseAsync = this.parseAsync.bind(this);\n this.safeParseAsync = this.safeParseAsync.bind(this);\n this.spa = this.spa.bind(this);\n this.refine = this.refine.bind(this);\n this.refinement = this.refinement.bind(this);\n this.superRefine = this.superRefine.bind(this);\n this.optional = this.optional.bind(this);\n this.nullable = this.nullable.bind(this);\n this.nullish = this.nullish.bind(this);\n this.array = this.array.bind(this);\n this.promise = this.promise.bind(this);\n this.or = this.or.bind(this);\n this.and = this.and.bind(this);\n this.transform = this.transform.bind(this);\n this.brand = this.brand.bind(this);\n this.default = this.default.bind(this);\n this.catch = this.catch.bind(this);\n this.describe = this.describe.bind(this);\n this.pipe = this.pipe.bind(this);\n this.readonly = this.readonly.bind(this);\n this.isNullable = this.isNullable.bind(this);\n this.isOptional = this.isOptional.bind(this);\n this[\"~standard\"] = {\n version: 1,\n vendor: \"zod\",\n validate: (data) => this[\"~validate\"](data),\n };\n }\n optional() {\n return ZodOptional.create(this, this._def);\n }\n nullable() {\n return ZodNullable.create(this, this._def);\n }\n nullish() {\n return this.nullable().optional();\n }\n array() {\n return ZodArray.create(this);\n }\n promise() {\n return ZodPromise.create(this, this._def);\n }\n or(option) {\n return ZodUnion.create([this, option], this._def);\n }\n and(incoming) {\n return ZodIntersection.create(this, incoming, this._def);\n }\n transform(transform) {\n return new ZodEffects({\n ...processCreateParams(this._def),\n schema: this,\n typeName: ZodFirstPartyTypeKind.ZodEffects,\n effect: { type: \"transform\", transform },\n });\n }\n default(def) {\n const defaultValueFunc = typeof def === \"function\" ? def : () => def;\n return new ZodDefault({\n ...processCreateParams(this._def),\n innerType: this,\n defaultValue: defaultValueFunc,\n typeName: ZodFirstPartyTypeKind.ZodDefault,\n });\n }\n brand() {\n return new ZodBranded({\n typeName: ZodFirstPartyTypeKind.ZodBranded,\n type: this,\n ...processCreateParams(this._def),\n });\n }\n catch(def) {\n const catchValueFunc = typeof def === \"function\" ? def : () => def;\n return new ZodCatch({\n ...processCreateParams(this._def),\n innerType: this,\n catchValue: catchValueFunc,\n typeName: ZodFirstPartyTypeKind.ZodCatch,\n });\n }\n describe(description) {\n const This = this.constructor;\n return new This({\n ...this._def,\n description,\n });\n }\n pipe(target) {\n return ZodPipeline.create(this, target);\n }\n readonly() {\n return ZodReadonly.create(this);\n }\n isOptional() {\n return this.safeParse(undefined).success;\n }\n isNullable() {\n return this.safeParse(null).success;\n }\n}\nconst cuidRegex = /^c[^\\s-]{8,}$/i;\nconst cuid2Regex = /^[0-9a-z]+$/;\nconst ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;\n// const uuidRegex =\n// /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;\nconst uuidRegex = /^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$/i;\nconst nanoidRegex = /^[a-z0-9_-]{21}$/i;\nconst jwtRegex = /^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$/;\nconst durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\\d+Y)|(?:[-+]?\\d+[.,]\\d+Y$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:(?:[-+]?\\d+W)|(?:[-+]?\\d+[.,]\\d+W$))?(?:(?:[-+]?\\d+D)|(?:[-+]?\\d+[.,]\\d+D$))?(?:T(?=[\\d+-])(?:(?:[-+]?\\d+H)|(?:[-+]?\\d+[.,]\\d+H$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:[-+]?\\d+(?:[.,]\\d+)?S)?)??$/;\n// from https://stackoverflow.com/a/46181/1550155\n// old version: too slow, didn't support unicode\n// const emailRegex = /^((([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+(\\.([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(\\\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))\\.)+(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))$/i;\n//old email regex\n// const emailRegex = /^(([^<>()[\\].,;:\\s@\"]+(\\.[^<>()[\\].,;:\\s@\"]+)*)|(\".+\"))@((?!-)([^<>()[\\].,;:\\s@\"]+\\.)+[^<>()[\\].,;:\\s@\"]{1,})[^-<>()[\\].,;:\\s@\"]$/i;\n// eslint-disable-next-line\n// const emailRegex =\n// /^(([^<>()[\\]\\\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@((\\[(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\])|(\\[IPv6:(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))\\])|([A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])*(\\.[A-Za-z]{2,})+))$/;\n// const emailRegex =\n// /^[a-zA-Z0-9\\.\\!\\#\\$\\%\\&\\'\\*\\+\\/\\=\\?\\^\\_\\`\\{\\|\\}\\~\\-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n// const emailRegex =\n// /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])$/i;\nconst emailRegex = /^(?!\\.)(?!.*\\.\\.)([A-Z0-9_'+\\-\\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\\-]*\\.)+[A-Z]{2,}$/i;\n// const emailRegex =\n// /^[a-z0-9.!#$%&\u2019*+/=?^_`{|}~-]+@[a-z0-9-]+(?:\\.[a-z0-9\\-]+)*$/i;\n// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression\nconst _emojiRegex = `^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$`;\nlet emojiRegex;\n// faster, simpler, safer\nconst ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\nconst ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/(3[0-2]|[12]?[0-9])$/;\n// const ipv6Regex =\n// /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;\nconst ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;\nconst ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\n// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript\nconst base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;\n// https://base64.guru/standards/base64url\nconst base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;\n// simple\n// const dateRegexSource = `\\\\d{4}-\\\\d{2}-\\\\d{2}`;\n// no leap year validation\n// const dateRegexSource = `\\\\d{4}-((0[13578]|10|12)-31|(0[13-9]|1[0-2])-30|(0[1-9]|1[0-2])-(0[1-9]|1\\\\d|2\\\\d))`;\n// with leap year validation\nconst dateRegexSource = `((\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\\\d|30)|(02)-(0[1-9]|1\\\\d|2[0-8])))`;\nconst dateRegex = new RegExp(`^${dateRegexSource}$`);\nfunction timeRegexSource(args) {\n let secondsRegexSource = `[0-5]\\\\d`;\n if (args.precision) {\n secondsRegexSource = `${secondsRegexSource}\\\\.\\\\d{${args.precision}}`;\n }\n else if (args.precision == null) {\n secondsRegexSource = `${secondsRegexSource}(\\\\.\\\\d+)?`;\n }\n const secondsQuantifier = args.precision ? \"+\" : \"?\"; // require seconds if precision is nonzero\n return `([01]\\\\d|2[0-3]):[0-5]\\\\d(:${secondsRegexSource})${secondsQuantifier}`;\n}\nfunction timeRegex(args) {\n return new RegExp(`^${timeRegexSource(args)}$`);\n}\n// Adapted from https://stackoverflow.com/a/3143231\nexport function datetimeRegex(args) {\n let regex = `${dateRegexSource}T${timeRegexSource(args)}`;\n const opts = [];\n opts.push(args.local ? `Z?` : `Z`);\n if (args.offset)\n opts.push(`([+-]\\\\d{2}:?\\\\d{2})`);\n regex = `${regex}(${opts.join(\"|\")})`;\n return new RegExp(`^${regex}$`);\n}\nfunction isValidIP(ip, version) {\n if ((version === \"v4\" || !version) && ipv4Regex.test(ip)) {\n return true;\n }\n if ((version === \"v6\" || !version) && ipv6Regex.test(ip)) {\n return true;\n }\n return false;\n}\nfunction isValidJWT(jwt, alg) {\n if (!jwtRegex.test(jwt))\n return false;\n try {\n const [header] = jwt.split(\".\");\n if (!header)\n return false;\n // Convert base64url to base64\n const base64 = header\n .replace(/-/g, \"+\")\n .replace(/_/g, \"/\")\n .padEnd(header.length + ((4 - (header.length % 4)) % 4), \"=\");\n // @ts-ignore\n const decoded = JSON.parse(atob(base64));\n if (typeof decoded !== \"object\" || decoded === null)\n return false;\n if (\"typ\" in decoded && decoded?.typ !== \"JWT\")\n return false;\n if (!decoded.alg)\n return false;\n if (alg && decoded.alg !== alg)\n return false;\n return true;\n }\n catch {\n return false;\n }\n}\nfunction isValidCidr(ip, version) {\n if ((version === \"v4\" || !version) && ipv4CidrRegex.test(ip)) {\n return true;\n }\n if ((version === \"v6\" || !version) && ipv6CidrRegex.test(ip)) {\n return true;\n }\n return false;\n}\nexport class ZodString extends ZodType {\n _parse(input) {\n if (this._def.coerce) {\n input.data = String(input.data);\n }\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.string) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.string,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n const status = new ParseStatus();\n let ctx = undefined;\n for (const check of this._def.checks) {\n if (check.kind === \"min\") {\n if (input.data.length < check.value) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n minimum: check.value,\n type: \"string\",\n inclusive: true,\n exact: false,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"max\") {\n if (input.data.length > check.value) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n maximum: check.value,\n type: \"string\",\n inclusive: true,\n exact: false,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"length\") {\n const tooBig = input.data.length > check.value;\n const tooSmall = input.data.length < check.value;\n if (tooBig || tooSmall) {\n ctx = this._getOrReturnCtx(input, ctx);\n if (tooBig) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n maximum: check.value,\n type: \"string\",\n inclusive: true,\n exact: true,\n message: check.message,\n });\n }\n else if (tooSmall) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n minimum: check.value,\n type: \"string\",\n inclusive: true,\n exact: true,\n message: check.message,\n });\n }\n status.dirty();\n }\n }\n else if (check.kind === \"email\") {\n if (!emailRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"email\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"emoji\") {\n if (!emojiRegex) {\n emojiRegex = new RegExp(_emojiRegex, \"u\");\n }\n if (!emojiRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"emoji\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"uuid\") {\n if (!uuidRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"uuid\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"nanoid\") {\n if (!nanoidRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"nanoid\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"cuid\") {\n if (!cuidRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"cuid\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"cuid2\") {\n if (!cuid2Regex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"cuid2\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"ulid\") {\n if (!ulidRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"ulid\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"url\") {\n try {\n // @ts-ignore\n new URL(input.data);\n }\n catch {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"url\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"regex\") {\n check.regex.lastIndex = 0;\n const testResult = check.regex.test(input.data);\n if (!testResult) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"regex\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"trim\") {\n input.data = input.data.trim();\n }\n else if (check.kind === \"includes\") {\n if (!input.data.includes(check.value, check.position)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_string,\n validation: { includes: check.value, position: check.position },\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"toLowerCase\") {\n input.data = input.data.toLowerCase();\n }\n else if (check.kind === \"toUpperCase\") {\n input.data = input.data.toUpperCase();\n }\n else if (check.kind === \"startsWith\") {\n if (!input.data.startsWith(check.value)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_string,\n validation: { startsWith: check.value },\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"endsWith\") {\n if (!input.data.endsWith(check.value)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_string,\n validation: { endsWith: check.value },\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"datetime\") {\n const regex = datetimeRegex(check);\n if (!regex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_string,\n validation: \"datetime\",\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"date\") {\n const regex = dateRegex;\n if (!regex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_string,\n validation: \"date\",\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"time\") {\n const regex = timeRegex(check);\n if (!regex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_string,\n validation: \"time\",\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"duration\") {\n if (!durationRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"duration\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"ip\") {\n if (!isValidIP(input.data, check.version)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"ip\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"jwt\") {\n if (!isValidJWT(input.data, check.alg)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"jwt\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"cidr\") {\n if (!isValidCidr(input.data, check.version)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"cidr\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"base64\") {\n if (!base64Regex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"base64\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"base64url\") {\n if (!base64urlRegex.test(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n validation: \"base64url\",\n code: ZodIssueCode.invalid_string,\n message: check.message,\n });\n status.dirty();\n }\n }\n else {\n util.assertNever(check);\n }\n }\n return { status: status.value, value: input.data };\n }\n _regex(regex, validation, message) {\n return this.refinement((data) => regex.test(data), {\n validation,\n code: ZodIssueCode.invalid_string,\n ...errorUtil.errToObj(message),\n });\n }\n _addCheck(check) {\n return new ZodString({\n ...this._def,\n checks: [...this._def.checks, check],\n });\n }\n email(message) {\n return this._addCheck({ kind: \"email\", ...errorUtil.errToObj(message) });\n }\n url(message) {\n return this._addCheck({ kind: \"url\", ...errorUtil.errToObj(message) });\n }\n emoji(message) {\n return this._addCheck({ kind: \"emoji\", ...errorUtil.errToObj(message) });\n }\n uuid(message) {\n return this._addCheck({ kind: \"uuid\", ...errorUtil.errToObj(message) });\n }\n nanoid(message) {\n return this._addCheck({ kind: \"nanoid\", ...errorUtil.errToObj(message) });\n }\n cuid(message) {\n return this._addCheck({ kind: \"cuid\", ...errorUtil.errToObj(message) });\n }\n cuid2(message) {\n return this._addCheck({ kind: \"cuid2\", ...errorUtil.errToObj(message) });\n }\n ulid(message) {\n return this._addCheck({ kind: \"ulid\", ...errorUtil.errToObj(message) });\n }\n base64(message) {\n return this._addCheck({ kind: \"base64\", ...errorUtil.errToObj(message) });\n }\n base64url(message) {\n // base64url encoding is a modification of base64 that can safely be used in URLs and filenames\n return this._addCheck({\n kind: \"base64url\",\n ...errorUtil.errToObj(message),\n });\n }\n jwt(options) {\n return this._addCheck({ kind: \"jwt\", ...errorUtil.errToObj(options) });\n }\n ip(options) {\n return this._addCheck({ kind: \"ip\", ...errorUtil.errToObj(options) });\n }\n cidr(options) {\n return this._addCheck({ kind: \"cidr\", ...errorUtil.errToObj(options) });\n }\n datetime(options) {\n if (typeof options === \"string\") {\n return this._addCheck({\n kind: \"datetime\",\n precision: null,\n offset: false,\n local: false,\n message: options,\n });\n }\n return this._addCheck({\n kind: \"datetime\",\n precision: typeof options?.precision === \"undefined\" ? null : options?.precision,\n offset: options?.offset ?? false,\n local: options?.local ?? false,\n ...errorUtil.errToObj(options?.message),\n });\n }\n date(message) {\n return this._addCheck({ kind: \"date\", message });\n }\n time(options) {\n if (typeof options === \"string\") {\n return this._addCheck({\n kind: \"time\",\n precision: null,\n message: options,\n });\n }\n return this._addCheck({\n kind: \"time\",\n precision: typeof options?.precision === \"undefined\" ? null : options?.precision,\n ...errorUtil.errToObj(options?.message),\n });\n }\n duration(message) {\n return this._addCheck({ kind: \"duration\", ...errorUtil.errToObj(message) });\n }\n regex(regex, message) {\n return this._addCheck({\n kind: \"regex\",\n regex: regex,\n ...errorUtil.errToObj(message),\n });\n }\n includes(value, options) {\n return this._addCheck({\n kind: \"includes\",\n value: value,\n position: options?.position,\n ...errorUtil.errToObj(options?.message),\n });\n }\n startsWith(value, message) {\n return this._addCheck({\n kind: \"startsWith\",\n value: value,\n ...errorUtil.errToObj(message),\n });\n }\n endsWith(value, message) {\n return this._addCheck({\n kind: \"endsWith\",\n value: value,\n ...errorUtil.errToObj(message),\n });\n }\n min(minLength, message) {\n return this._addCheck({\n kind: \"min\",\n value: minLength,\n ...errorUtil.errToObj(message),\n });\n }\n max(maxLength, message) {\n return this._addCheck({\n kind: \"max\",\n value: maxLength,\n ...errorUtil.errToObj(message),\n });\n }\n length(len, message) {\n return this._addCheck({\n kind: \"length\",\n value: len,\n ...errorUtil.errToObj(message),\n });\n }\n /**\n * Equivalent to `.min(1)`\n */\n nonempty(message) {\n return this.min(1, errorUtil.errToObj(message));\n }\n trim() {\n return new ZodString({\n ...this._def,\n checks: [...this._def.checks, { kind: \"trim\" }],\n });\n }\n toLowerCase() {\n return new ZodString({\n ...this._def,\n checks: [...this._def.checks, { kind: \"toLowerCase\" }],\n });\n }\n toUpperCase() {\n return new ZodString({\n ...this._def,\n checks: [...this._def.checks, { kind: \"toUpperCase\" }],\n });\n }\n get isDatetime() {\n return !!this._def.checks.find((ch) => ch.kind === \"datetime\");\n }\n get isDate() {\n return !!this._def.checks.find((ch) => ch.kind === \"date\");\n }\n get isTime() {\n return !!this._def.checks.find((ch) => ch.kind === \"time\");\n }\n get isDuration() {\n return !!this._def.checks.find((ch) => ch.kind === \"duration\");\n }\n get isEmail() {\n return !!this._def.checks.find((ch) => ch.kind === \"email\");\n }\n get isURL() {\n return !!this._def.checks.find((ch) => ch.kind === \"url\");\n }\n get isEmoji() {\n return !!this._def.checks.find((ch) => ch.kind === \"emoji\");\n }\n get isUUID() {\n return !!this._def.checks.find((ch) => ch.kind === \"uuid\");\n }\n get isNANOID() {\n return !!this._def.checks.find((ch) => ch.kind === \"nanoid\");\n }\n get isCUID() {\n return !!this._def.checks.find((ch) => ch.kind === \"cuid\");\n }\n get isCUID2() {\n return !!this._def.checks.find((ch) => ch.kind === \"cuid2\");\n }\n get isULID() {\n return !!this._def.checks.find((ch) => ch.kind === \"ulid\");\n }\n get isIP() {\n return !!this._def.checks.find((ch) => ch.kind === \"ip\");\n }\n get isCIDR() {\n return !!this._def.checks.find((ch) => ch.kind === \"cidr\");\n }\n get isBase64() {\n return !!this._def.checks.find((ch) => ch.kind === \"base64\");\n }\n get isBase64url() {\n // base64url encoding is a modification of base64 that can safely be used in URLs and filenames\n return !!this._def.checks.find((ch) => ch.kind === \"base64url\");\n }\n get minLength() {\n let min = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"min\") {\n if (min === null || ch.value > min)\n min = ch.value;\n }\n }\n return min;\n }\n get maxLength() {\n let max = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"max\") {\n if (max === null || ch.value < max)\n max = ch.value;\n }\n }\n return max;\n }\n}\nZodString.create = (params) => {\n return new ZodString({\n checks: [],\n typeName: ZodFirstPartyTypeKind.ZodString,\n coerce: params?.coerce ?? false,\n ...processCreateParams(params),\n });\n};\n// https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034\nfunction floatSafeRemainder(val, step) {\n const valDecCount = (val.toString().split(\".\")[1] || \"\").length;\n const stepDecCount = (step.toString().split(\".\")[1] || \"\").length;\n const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;\n const valInt = Number.parseInt(val.toFixed(decCount).replace(\".\", \"\"));\n const stepInt = Number.parseInt(step.toFixed(decCount).replace(\".\", \"\"));\n return (valInt % stepInt) / 10 ** decCount;\n}\nexport class ZodNumber extends ZodType {\n constructor() {\n super(...arguments);\n this.min = this.gte;\n this.max = this.lte;\n this.step = this.multipleOf;\n }\n _parse(input) {\n if (this._def.coerce) {\n input.data = Number(input.data);\n }\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.number) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.number,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n let ctx = undefined;\n const status = new ParseStatus();\n for (const check of this._def.checks) {\n if (check.kind === \"int\") {\n if (!util.isInteger(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: \"integer\",\n received: \"float\",\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"min\") {\n const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;\n if (tooSmall) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n minimum: check.value,\n type: \"number\",\n inclusive: check.inclusive,\n exact: false,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"max\") {\n const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;\n if (tooBig) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n maximum: check.value,\n type: \"number\",\n inclusive: check.inclusive,\n exact: false,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"multipleOf\") {\n if (floatSafeRemainder(input.data, check.value) !== 0) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.not_multiple_of,\n multipleOf: check.value,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"finite\") {\n if (!Number.isFinite(input.data)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.not_finite,\n message: check.message,\n });\n status.dirty();\n }\n }\n else {\n util.assertNever(check);\n }\n }\n return { status: status.value, value: input.data };\n }\n gte(value, message) {\n return this.setLimit(\"min\", value, true, errorUtil.toString(message));\n }\n gt(value, message) {\n return this.setLimit(\"min\", value, false, errorUtil.toString(message));\n }\n lte(value, message) {\n return this.setLimit(\"max\", value, true, errorUtil.toString(message));\n }\n lt(value, message) {\n return this.setLimit(\"max\", value, false, errorUtil.toString(message));\n }\n setLimit(kind, value, inclusive, message) {\n return new ZodNumber({\n ...this._def,\n checks: [\n ...this._def.checks,\n {\n kind,\n value,\n inclusive,\n message: errorUtil.toString(message),\n },\n ],\n });\n }\n _addCheck(check) {\n return new ZodNumber({\n ...this._def,\n checks: [...this._def.checks, check],\n });\n }\n int(message) {\n return this._addCheck({\n kind: \"int\",\n message: errorUtil.toString(message),\n });\n }\n positive(message) {\n return this._addCheck({\n kind: \"min\",\n value: 0,\n inclusive: false,\n message: errorUtil.toString(message),\n });\n }\n negative(message) {\n return this._addCheck({\n kind: \"max\",\n value: 0,\n inclusive: false,\n message: errorUtil.toString(message),\n });\n }\n nonpositive(message) {\n return this._addCheck({\n kind: \"max\",\n value: 0,\n inclusive: true,\n message: errorUtil.toString(message),\n });\n }\n nonnegative(message) {\n return this._addCheck({\n kind: \"min\",\n value: 0,\n inclusive: true,\n message: errorUtil.toString(message),\n });\n }\n multipleOf(value, message) {\n return this._addCheck({\n kind: \"multipleOf\",\n value: value,\n message: errorUtil.toString(message),\n });\n }\n finite(message) {\n return this._addCheck({\n kind: \"finite\",\n message: errorUtil.toString(message),\n });\n }\n safe(message) {\n return this._addCheck({\n kind: \"min\",\n inclusive: true,\n value: Number.MIN_SAFE_INTEGER,\n message: errorUtil.toString(message),\n })._addCheck({\n kind: \"max\",\n inclusive: true,\n value: Number.MAX_SAFE_INTEGER,\n message: errorUtil.toString(message),\n });\n }\n get minValue() {\n let min = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"min\") {\n if (min === null || ch.value > min)\n min = ch.value;\n }\n }\n return min;\n }\n get maxValue() {\n let max = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"max\") {\n if (max === null || ch.value < max)\n max = ch.value;\n }\n }\n return max;\n }\n get isInt() {\n return !!this._def.checks.find((ch) => ch.kind === \"int\" || (ch.kind === \"multipleOf\" && util.isInteger(ch.value)));\n }\n get isFinite() {\n let max = null;\n let min = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"finite\" || ch.kind === \"int\" || ch.kind === \"multipleOf\") {\n return true;\n }\n else if (ch.kind === \"min\") {\n if (min === null || ch.value > min)\n min = ch.value;\n }\n else if (ch.kind === \"max\") {\n if (max === null || ch.value < max)\n max = ch.value;\n }\n }\n return Number.isFinite(min) && Number.isFinite(max);\n }\n}\nZodNumber.create = (params) => {\n return new ZodNumber({\n checks: [],\n typeName: ZodFirstPartyTypeKind.ZodNumber,\n coerce: params?.coerce || false,\n ...processCreateParams(params),\n });\n};\nexport class ZodBigInt extends ZodType {\n constructor() {\n super(...arguments);\n this.min = this.gte;\n this.max = this.lte;\n }\n _parse(input) {\n if (this._def.coerce) {\n try {\n input.data = BigInt(input.data);\n }\n catch {\n return this._getInvalidInput(input);\n }\n }\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.bigint) {\n return this._getInvalidInput(input);\n }\n let ctx = undefined;\n const status = new ParseStatus();\n for (const check of this._def.checks) {\n if (check.kind === \"min\") {\n const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;\n if (tooSmall) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n type: \"bigint\",\n minimum: check.value,\n inclusive: check.inclusive,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"max\") {\n const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;\n if (tooBig) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n type: \"bigint\",\n maximum: check.value,\n inclusive: check.inclusive,\n message: check.message,\n });\n status.dirty();\n }\n }\n else if (check.kind === \"multipleOf\") {\n if (input.data % check.value !== BigInt(0)) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.not_multiple_of,\n multipleOf: check.value,\n message: check.message,\n });\n status.dirty();\n }\n }\n else {\n util.assertNever(check);\n }\n }\n return { status: status.value, value: input.data };\n }\n _getInvalidInput(input) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.bigint,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n gte(value, message) {\n return this.setLimit(\"min\", value, true, errorUtil.toString(message));\n }\n gt(value, message) {\n return this.setLimit(\"min\", value, false, errorUtil.toString(message));\n }\n lte(value, message) {\n return this.setLimit(\"max\", value, true, errorUtil.toString(message));\n }\n lt(value, message) {\n return this.setLimit(\"max\", value, false, errorUtil.toString(message));\n }\n setLimit(kind, value, inclusive, message) {\n return new ZodBigInt({\n ...this._def,\n checks: [\n ...this._def.checks,\n {\n kind,\n value,\n inclusive,\n message: errorUtil.toString(message),\n },\n ],\n });\n }\n _addCheck(check) {\n return new ZodBigInt({\n ...this._def,\n checks: [...this._def.checks, check],\n });\n }\n positive(message) {\n return this._addCheck({\n kind: \"min\",\n value: BigInt(0),\n inclusive: false,\n message: errorUtil.toString(message),\n });\n }\n negative(message) {\n return this._addCheck({\n kind: \"max\",\n value: BigInt(0),\n inclusive: false,\n message: errorUtil.toString(message),\n });\n }\n nonpositive(message) {\n return this._addCheck({\n kind: \"max\",\n value: BigInt(0),\n inclusive: true,\n message: errorUtil.toString(message),\n });\n }\n nonnegative(message) {\n return this._addCheck({\n kind: \"min\",\n value: BigInt(0),\n inclusive: true,\n message: errorUtil.toString(message),\n });\n }\n multipleOf(value, message) {\n return this._addCheck({\n kind: \"multipleOf\",\n value,\n message: errorUtil.toString(message),\n });\n }\n get minValue() {\n let min = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"min\") {\n if (min === null || ch.value > min)\n min = ch.value;\n }\n }\n return min;\n }\n get maxValue() {\n let max = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"max\") {\n if (max === null || ch.value < max)\n max = ch.value;\n }\n }\n return max;\n }\n}\nZodBigInt.create = (params) => {\n return new ZodBigInt({\n checks: [],\n typeName: ZodFirstPartyTypeKind.ZodBigInt,\n coerce: params?.coerce ?? false,\n ...processCreateParams(params),\n });\n};\nexport class ZodBoolean extends ZodType {\n _parse(input) {\n if (this._def.coerce) {\n input.data = Boolean(input.data);\n }\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.boolean) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.boolean,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n return OK(input.data);\n }\n}\nZodBoolean.create = (params) => {\n return new ZodBoolean({\n typeName: ZodFirstPartyTypeKind.ZodBoolean,\n coerce: params?.coerce || false,\n ...processCreateParams(params),\n });\n};\nexport class ZodDate extends ZodType {\n _parse(input) {\n if (this._def.coerce) {\n input.data = new Date(input.data);\n }\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.date) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.date,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n if (Number.isNaN(input.data.getTime())) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_date,\n });\n return INVALID;\n }\n const status = new ParseStatus();\n let ctx = undefined;\n for (const check of this._def.checks) {\n if (check.kind === \"min\") {\n if (input.data.getTime() < check.value) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n message: check.message,\n inclusive: true,\n exact: false,\n minimum: check.value,\n type: \"date\",\n });\n status.dirty();\n }\n }\n else if (check.kind === \"max\") {\n if (input.data.getTime() > check.value) {\n ctx = this._getOrReturnCtx(input, ctx);\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n message: check.message,\n inclusive: true,\n exact: false,\n maximum: check.value,\n type: \"date\",\n });\n status.dirty();\n }\n }\n else {\n util.assertNever(check);\n }\n }\n return {\n status: status.value,\n value: new Date(input.data.getTime()),\n };\n }\n _addCheck(check) {\n return new ZodDate({\n ...this._def,\n checks: [...this._def.checks, check],\n });\n }\n min(minDate, message) {\n return this._addCheck({\n kind: \"min\",\n value: minDate.getTime(),\n message: errorUtil.toString(message),\n });\n }\n max(maxDate, message) {\n return this._addCheck({\n kind: \"max\",\n value: maxDate.getTime(),\n message: errorUtil.toString(message),\n });\n }\n get minDate() {\n let min = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"min\") {\n if (min === null || ch.value > min)\n min = ch.value;\n }\n }\n return min != null ? new Date(min) : null;\n }\n get maxDate() {\n let max = null;\n for (const ch of this._def.checks) {\n if (ch.kind === \"max\") {\n if (max === null || ch.value < max)\n max = ch.value;\n }\n }\n return max != null ? new Date(max) : null;\n }\n}\nZodDate.create = (params) => {\n return new ZodDate({\n checks: [],\n coerce: params?.coerce || false,\n typeName: ZodFirstPartyTypeKind.ZodDate,\n ...processCreateParams(params),\n });\n};\nexport class ZodSymbol extends ZodType {\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.symbol) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.symbol,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n return OK(input.data);\n }\n}\nZodSymbol.create = (params) => {\n return new ZodSymbol({\n typeName: ZodFirstPartyTypeKind.ZodSymbol,\n ...processCreateParams(params),\n });\n};\nexport class ZodUndefined extends ZodType {\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.undefined) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.undefined,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n return OK(input.data);\n }\n}\nZodUndefined.create = (params) => {\n return new ZodUndefined({\n typeName: ZodFirstPartyTypeKind.ZodUndefined,\n ...processCreateParams(params),\n });\n};\nexport class ZodNull extends ZodType {\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.null) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.null,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n return OK(input.data);\n }\n}\nZodNull.create = (params) => {\n return new ZodNull({\n typeName: ZodFirstPartyTypeKind.ZodNull,\n ...processCreateParams(params),\n });\n};\nexport class ZodAny extends ZodType {\n constructor() {\n super(...arguments);\n // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.\n this._any = true;\n }\n _parse(input) {\n return OK(input.data);\n }\n}\nZodAny.create = (params) => {\n return new ZodAny({\n typeName: ZodFirstPartyTypeKind.ZodAny,\n ...processCreateParams(params),\n });\n};\nexport class ZodUnknown extends ZodType {\n constructor() {\n super(...arguments);\n // required\n this._unknown = true;\n }\n _parse(input) {\n return OK(input.data);\n }\n}\nZodUnknown.create = (params) => {\n return new ZodUnknown({\n typeName: ZodFirstPartyTypeKind.ZodUnknown,\n ...processCreateParams(params),\n });\n};\nexport class ZodNever extends ZodType {\n _parse(input) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.never,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n}\nZodNever.create = (params) => {\n return new ZodNever({\n typeName: ZodFirstPartyTypeKind.ZodNever,\n ...processCreateParams(params),\n });\n};\nexport class ZodVoid extends ZodType {\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.undefined) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.void,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n return OK(input.data);\n }\n}\nZodVoid.create = (params) => {\n return new ZodVoid({\n typeName: ZodFirstPartyTypeKind.ZodVoid,\n ...processCreateParams(params),\n });\n};\nexport class ZodArray extends ZodType {\n _parse(input) {\n const { ctx, status } = this._processInputParams(input);\n const def = this._def;\n if (ctx.parsedType !== ZodParsedType.array) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.array,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n if (def.exactLength !== null) {\n const tooBig = ctx.data.length > def.exactLength.value;\n const tooSmall = ctx.data.length < def.exactLength.value;\n if (tooBig || tooSmall) {\n addIssueToContext(ctx, {\n code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,\n minimum: (tooSmall ? def.exactLength.value : undefined),\n maximum: (tooBig ? def.exactLength.value : undefined),\n type: \"array\",\n inclusive: true,\n exact: true,\n message: def.exactLength.message,\n });\n status.dirty();\n }\n }\n if (def.minLength !== null) {\n if (ctx.data.length < def.minLength.value) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n minimum: def.minLength.value,\n type: \"array\",\n inclusive: true,\n exact: false,\n message: def.minLength.message,\n });\n status.dirty();\n }\n }\n if (def.maxLength !== null) {\n if (ctx.data.length > def.maxLength.value) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n maximum: def.maxLength.value,\n type: \"array\",\n inclusive: true,\n exact: false,\n message: def.maxLength.message,\n });\n status.dirty();\n }\n }\n if (ctx.common.async) {\n return Promise.all([...ctx.data].map((item, i) => {\n return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));\n })).then((result) => {\n return ParseStatus.mergeArray(status, result);\n });\n }\n const result = [...ctx.data].map((item, i) => {\n return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));\n });\n return ParseStatus.mergeArray(status, result);\n }\n get element() {\n return this._def.type;\n }\n min(minLength, message) {\n return new ZodArray({\n ...this._def,\n minLength: { value: minLength, message: errorUtil.toString(message) },\n });\n }\n max(maxLength, message) {\n return new ZodArray({\n ...this._def,\n maxLength: { value: maxLength, message: errorUtil.toString(message) },\n });\n }\n length(len, message) {\n return new ZodArray({\n ...this._def,\n exactLength: { value: len, message: errorUtil.toString(message) },\n });\n }\n nonempty(message) {\n return this.min(1, message);\n }\n}\nZodArray.create = (schema, params) => {\n return new ZodArray({\n type: schema,\n minLength: null,\n maxLength: null,\n exactLength: null,\n typeName: ZodFirstPartyTypeKind.ZodArray,\n ...processCreateParams(params),\n });\n};\nfunction deepPartialify(schema) {\n if (schema instanceof ZodObject) {\n const newShape = {};\n for (const key in schema.shape) {\n const fieldSchema = schema.shape[key];\n newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));\n }\n return new ZodObject({\n ...schema._def,\n shape: () => newShape,\n });\n }\n else if (schema instanceof ZodArray) {\n return new ZodArray({\n ...schema._def,\n type: deepPartialify(schema.element),\n });\n }\n else if (schema instanceof ZodOptional) {\n return ZodOptional.create(deepPartialify(schema.unwrap()));\n }\n else if (schema instanceof ZodNullable) {\n return ZodNullable.create(deepPartialify(schema.unwrap()));\n }\n else if (schema instanceof ZodTuple) {\n return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));\n }\n else {\n return schema;\n }\n}\nexport class ZodObject extends ZodType {\n constructor() {\n super(...arguments);\n this._cached = null;\n /**\n * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.\n * If you want to pass through unknown properties, use `.passthrough()` instead.\n */\n this.nonstrict = this.passthrough;\n // extend<\n // Augmentation extends ZodRawShape,\n // NewOutput extends util.flatten<{\n // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation\n // ? Augmentation[k][\"_output\"]\n // : k extends keyof Output\n // ? Output[k]\n // : never;\n // }>,\n // NewInput extends util.flatten<{\n // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation\n // ? Augmentation[k][\"_input\"]\n // : k extends keyof Input\n // ? Input[k]\n // : never;\n // }>\n // >(\n // augmentation: Augmentation\n // ): ZodObject<\n // extendShape,\n // UnknownKeys,\n // Catchall,\n // NewOutput,\n // NewInput\n // > {\n // return new ZodObject({\n // ...this._def,\n // shape: () => ({\n // ...this._def.shape(),\n // ...augmentation,\n // }),\n // }) as any;\n // }\n /**\n * @deprecated Use `.extend` instead\n * */\n this.augment = this.extend;\n }\n _getCached() {\n if (this._cached !== null)\n return this._cached;\n const shape = this._def.shape();\n const keys = util.objectKeys(shape);\n this._cached = { shape, keys };\n return this._cached;\n }\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.object) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.object,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n const { status, ctx } = this._processInputParams(input);\n const { shape, keys: shapeKeys } = this._getCached();\n const extraKeys = [];\n if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === \"strip\")) {\n for (const key in ctx.data) {\n if (!shapeKeys.includes(key)) {\n extraKeys.push(key);\n }\n }\n }\n const pairs = [];\n for (const key of shapeKeys) {\n const keyValidator = shape[key];\n const value = ctx.data[key];\n pairs.push({\n key: { status: \"valid\", value: key },\n value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),\n alwaysSet: key in ctx.data,\n });\n }\n if (this._def.catchall instanceof ZodNever) {\n const unknownKeys = this._def.unknownKeys;\n if (unknownKeys === \"passthrough\") {\n for (const key of extraKeys) {\n pairs.push({\n key: { status: \"valid\", value: key },\n value: { status: \"valid\", value: ctx.data[key] },\n });\n }\n }\n else if (unknownKeys === \"strict\") {\n if (extraKeys.length > 0) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.unrecognized_keys,\n keys: extraKeys,\n });\n status.dirty();\n }\n }\n else if (unknownKeys === \"strip\") {\n }\n else {\n throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);\n }\n }\n else {\n // run catchall validation\n const catchall = this._def.catchall;\n for (const key of extraKeys) {\n const value = ctx.data[key];\n pairs.push({\n key: { status: \"valid\", value: key },\n value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)\n ),\n alwaysSet: key in ctx.data,\n });\n }\n }\n if (ctx.common.async) {\n return Promise.resolve()\n .then(async () => {\n const syncPairs = [];\n for (const pair of pairs) {\n const key = await pair.key;\n const value = await pair.value;\n syncPairs.push({\n key,\n value,\n alwaysSet: pair.alwaysSet,\n });\n }\n return syncPairs;\n })\n .then((syncPairs) => {\n return ParseStatus.mergeObjectSync(status, syncPairs);\n });\n }\n else {\n return ParseStatus.mergeObjectSync(status, pairs);\n }\n }\n get shape() {\n return this._def.shape();\n }\n strict(message) {\n errorUtil.errToObj;\n return new ZodObject({\n ...this._def,\n unknownKeys: \"strict\",\n ...(message !== undefined\n ? {\n errorMap: (issue, ctx) => {\n const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;\n if (issue.code === \"unrecognized_keys\")\n return {\n message: errorUtil.errToObj(message).message ?? defaultError,\n };\n return {\n message: defaultError,\n };\n },\n }\n : {}),\n });\n }\n strip() {\n return new ZodObject({\n ...this._def,\n unknownKeys: \"strip\",\n });\n }\n passthrough() {\n return new ZodObject({\n ...this._def,\n unknownKeys: \"passthrough\",\n });\n }\n // const AugmentFactory =\n // (def: Def) =>\n // (\n // augmentation: Augmentation\n // ): ZodObject<\n // extendShape, Augmentation>,\n // Def[\"unknownKeys\"],\n // Def[\"catchall\"]\n // > => {\n // return new ZodObject({\n // ...def,\n // shape: () => ({\n // ...def.shape(),\n // ...augmentation,\n // }),\n // }) as any;\n // };\n extend(augmentation) {\n return new ZodObject({\n ...this._def,\n shape: () => ({\n ...this._def.shape(),\n ...augmentation,\n }),\n });\n }\n /**\n * Prior to zod@1.0.12 there was a bug in the\n * inferred type of merged objects. Please\n * upgrade if you are experiencing issues.\n */\n merge(merging) {\n const merged = new ZodObject({\n unknownKeys: merging._def.unknownKeys,\n catchall: merging._def.catchall,\n shape: () => ({\n ...this._def.shape(),\n ...merging._def.shape(),\n }),\n typeName: ZodFirstPartyTypeKind.ZodObject,\n });\n return merged;\n }\n // merge<\n // Incoming extends AnyZodObject,\n // Augmentation extends Incoming[\"shape\"],\n // NewOutput extends {\n // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation\n // ? Augmentation[k][\"_output\"]\n // : k extends keyof Output\n // ? Output[k]\n // : never;\n // },\n // NewInput extends {\n // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation\n // ? Augmentation[k][\"_input\"]\n // : k extends keyof Input\n // ? Input[k]\n // : never;\n // }\n // >(\n // merging: Incoming\n // ): ZodObject<\n // extendShape>,\n // Incoming[\"_def\"][\"unknownKeys\"],\n // Incoming[\"_def\"][\"catchall\"],\n // NewOutput,\n // NewInput\n // > {\n // const merged: any = new ZodObject({\n // unknownKeys: merging._def.unknownKeys,\n // catchall: merging._def.catchall,\n // shape: () =>\n // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),\n // typeName: ZodFirstPartyTypeKind.ZodObject,\n // }) as any;\n // return merged;\n // }\n setKey(key, schema) {\n return this.augment({ [key]: schema });\n }\n // merge(\n // merging: Incoming\n // ): //ZodObject = (merging) => {\n // ZodObject<\n // extendShape>,\n // Incoming[\"_def\"][\"unknownKeys\"],\n // Incoming[\"_def\"][\"catchall\"]\n // > {\n // // const mergedShape = objectUtil.mergeShapes(\n // // this._def.shape(),\n // // merging._def.shape()\n // // );\n // const merged: any = new ZodObject({\n // unknownKeys: merging._def.unknownKeys,\n // catchall: merging._def.catchall,\n // shape: () =>\n // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),\n // typeName: ZodFirstPartyTypeKind.ZodObject,\n // }) as any;\n // return merged;\n // }\n catchall(index) {\n return new ZodObject({\n ...this._def,\n catchall: index,\n });\n }\n pick(mask) {\n const shape = {};\n for (const key of util.objectKeys(mask)) {\n if (mask[key] && this.shape[key]) {\n shape[key] = this.shape[key];\n }\n }\n return new ZodObject({\n ...this._def,\n shape: () => shape,\n });\n }\n omit(mask) {\n const shape = {};\n for (const key of util.objectKeys(this.shape)) {\n if (!mask[key]) {\n shape[key] = this.shape[key];\n }\n }\n return new ZodObject({\n ...this._def,\n shape: () => shape,\n });\n }\n /**\n * @deprecated\n */\n deepPartial() {\n return deepPartialify(this);\n }\n partial(mask) {\n const newShape = {};\n for (const key of util.objectKeys(this.shape)) {\n const fieldSchema = this.shape[key];\n if (mask && !mask[key]) {\n newShape[key] = fieldSchema;\n }\n else {\n newShape[key] = fieldSchema.optional();\n }\n }\n return new ZodObject({\n ...this._def,\n shape: () => newShape,\n });\n }\n required(mask) {\n const newShape = {};\n for (const key of util.objectKeys(this.shape)) {\n if (mask && !mask[key]) {\n newShape[key] = this.shape[key];\n }\n else {\n const fieldSchema = this.shape[key];\n let newField = fieldSchema;\n while (newField instanceof ZodOptional) {\n newField = newField._def.innerType;\n }\n newShape[key] = newField;\n }\n }\n return new ZodObject({\n ...this._def,\n shape: () => newShape,\n });\n }\n keyof() {\n return createZodEnum(util.objectKeys(this.shape));\n }\n}\nZodObject.create = (shape, params) => {\n return new ZodObject({\n shape: () => shape,\n unknownKeys: \"strip\",\n catchall: ZodNever.create(),\n typeName: ZodFirstPartyTypeKind.ZodObject,\n ...processCreateParams(params),\n });\n};\nZodObject.strictCreate = (shape, params) => {\n return new ZodObject({\n shape: () => shape,\n unknownKeys: \"strict\",\n catchall: ZodNever.create(),\n typeName: ZodFirstPartyTypeKind.ZodObject,\n ...processCreateParams(params),\n });\n};\nZodObject.lazycreate = (shape, params) => {\n return new ZodObject({\n shape,\n unknownKeys: \"strip\",\n catchall: ZodNever.create(),\n typeName: ZodFirstPartyTypeKind.ZodObject,\n ...processCreateParams(params),\n });\n};\nexport class ZodUnion extends ZodType {\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n const options = this._def.options;\n function handleResults(results) {\n // return first issue-free validation if it exists\n for (const result of results) {\n if (result.result.status === \"valid\") {\n return result.result;\n }\n }\n for (const result of results) {\n if (result.result.status === \"dirty\") {\n // add issues from dirty option\n ctx.common.issues.push(...result.ctx.common.issues);\n return result.result;\n }\n }\n // return invalid\n const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_union,\n unionErrors,\n });\n return INVALID;\n }\n if (ctx.common.async) {\n return Promise.all(options.map(async (option) => {\n const childCtx = {\n ...ctx,\n common: {\n ...ctx.common,\n issues: [],\n },\n parent: null,\n };\n return {\n result: await option._parseAsync({\n data: ctx.data,\n path: ctx.path,\n parent: childCtx,\n }),\n ctx: childCtx,\n };\n })).then(handleResults);\n }\n else {\n let dirty = undefined;\n const issues = [];\n for (const option of options) {\n const childCtx = {\n ...ctx,\n common: {\n ...ctx.common,\n issues: [],\n },\n parent: null,\n };\n const result = option._parseSync({\n data: ctx.data,\n path: ctx.path,\n parent: childCtx,\n });\n if (result.status === \"valid\") {\n return result;\n }\n else if (result.status === \"dirty\" && !dirty) {\n dirty = { result, ctx: childCtx };\n }\n if (childCtx.common.issues.length) {\n issues.push(childCtx.common.issues);\n }\n }\n if (dirty) {\n ctx.common.issues.push(...dirty.ctx.common.issues);\n return dirty.result;\n }\n const unionErrors = issues.map((issues) => new ZodError(issues));\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_union,\n unionErrors,\n });\n return INVALID;\n }\n }\n get options() {\n return this._def.options;\n }\n}\nZodUnion.create = (types, params) => {\n return new ZodUnion({\n options: types,\n typeName: ZodFirstPartyTypeKind.ZodUnion,\n ...processCreateParams(params),\n });\n};\n/////////////////////////////////////////////////////\n/////////////////////////////////////////////////////\n////////// //////////\n////////// ZodDiscriminatedUnion //////////\n////////// //////////\n/////////////////////////////////////////////////////\n/////////////////////////////////////////////////////\nconst getDiscriminator = (type) => {\n if (type instanceof ZodLazy) {\n return getDiscriminator(type.schema);\n }\n else if (type instanceof ZodEffects) {\n return getDiscriminator(type.innerType());\n }\n else if (type instanceof ZodLiteral) {\n return [type.value];\n }\n else if (type instanceof ZodEnum) {\n return type.options;\n }\n else if (type instanceof ZodNativeEnum) {\n // eslint-disable-next-line ban/ban\n return util.objectValues(type.enum);\n }\n else if (type instanceof ZodDefault) {\n return getDiscriminator(type._def.innerType);\n }\n else if (type instanceof ZodUndefined) {\n return [undefined];\n }\n else if (type instanceof ZodNull) {\n return [null];\n }\n else if (type instanceof ZodOptional) {\n return [undefined, ...getDiscriminator(type.unwrap())];\n }\n else if (type instanceof ZodNullable) {\n return [null, ...getDiscriminator(type.unwrap())];\n }\n else if (type instanceof ZodBranded) {\n return getDiscriminator(type.unwrap());\n }\n else if (type instanceof ZodReadonly) {\n return getDiscriminator(type.unwrap());\n }\n else if (type instanceof ZodCatch) {\n return getDiscriminator(type._def.innerType);\n }\n else {\n return [];\n }\n};\nexport class ZodDiscriminatedUnion extends ZodType {\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n if (ctx.parsedType !== ZodParsedType.object) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.object,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n const discriminator = this.discriminator;\n const discriminatorValue = ctx.data[discriminator];\n const option = this.optionsMap.get(discriminatorValue);\n if (!option) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_union_discriminator,\n options: Array.from(this.optionsMap.keys()),\n path: [discriminator],\n });\n return INVALID;\n }\n if (ctx.common.async) {\n return option._parseAsync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n });\n }\n else {\n return option._parseSync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n });\n }\n }\n get discriminator() {\n return this._def.discriminator;\n }\n get options() {\n return this._def.options;\n }\n get optionsMap() {\n return this._def.optionsMap;\n }\n /**\n * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.\n * However, it only allows a union of objects, all of which need to share a discriminator property. This property must\n * have a different value for each object in the union.\n * @param discriminator the name of the discriminator property\n * @param types an array of object schemas\n * @param params\n */\n static create(discriminator, options, params) {\n // Get all the valid discriminator values\n const optionsMap = new Map();\n // try {\n for (const type of options) {\n const discriminatorValues = getDiscriminator(type.shape[discriminator]);\n if (!discriminatorValues.length) {\n throw new Error(`A discriminator value for key \\`${discriminator}\\` could not be extracted from all schema options`);\n }\n for (const value of discriminatorValues) {\n if (optionsMap.has(value)) {\n throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);\n }\n optionsMap.set(value, type);\n }\n }\n return new ZodDiscriminatedUnion({\n typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,\n discriminator,\n options,\n optionsMap,\n ...processCreateParams(params),\n });\n }\n}\nfunction mergeValues(a, b) {\n const aType = getParsedType(a);\n const bType = getParsedType(b);\n if (a === b) {\n return { valid: true, data: a };\n }\n else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {\n const bKeys = util.objectKeys(b);\n const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);\n const newObj = { ...a, ...b };\n for (const key of sharedKeys) {\n const sharedValue = mergeValues(a[key], b[key]);\n if (!sharedValue.valid) {\n return { valid: false };\n }\n newObj[key] = sharedValue.data;\n }\n return { valid: true, data: newObj };\n }\n else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {\n if (a.length !== b.length) {\n return { valid: false };\n }\n const newArray = [];\n for (let index = 0; index < a.length; index++) {\n const itemA = a[index];\n const itemB = b[index];\n const sharedValue = mergeValues(itemA, itemB);\n if (!sharedValue.valid) {\n return { valid: false };\n }\n newArray.push(sharedValue.data);\n }\n return { valid: true, data: newArray };\n }\n else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {\n return { valid: true, data: a };\n }\n else {\n return { valid: false };\n }\n}\nexport class ZodIntersection extends ZodType {\n _parse(input) {\n const { status, ctx } = this._processInputParams(input);\n const handleParsed = (parsedLeft, parsedRight) => {\n if (isAborted(parsedLeft) || isAborted(parsedRight)) {\n return INVALID;\n }\n const merged = mergeValues(parsedLeft.value, parsedRight.value);\n if (!merged.valid) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_intersection_types,\n });\n return INVALID;\n }\n if (isDirty(parsedLeft) || isDirty(parsedRight)) {\n status.dirty();\n }\n return { status: status.value, value: merged.data };\n };\n if (ctx.common.async) {\n return Promise.all([\n this._def.left._parseAsync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n }),\n this._def.right._parseAsync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n }),\n ]).then(([left, right]) => handleParsed(left, right));\n }\n else {\n return handleParsed(this._def.left._parseSync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n }), this._def.right._parseSync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n }));\n }\n }\n}\nZodIntersection.create = (left, right, params) => {\n return new ZodIntersection({\n left: left,\n right: right,\n typeName: ZodFirstPartyTypeKind.ZodIntersection,\n ...processCreateParams(params),\n });\n};\n// type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];\nexport class ZodTuple extends ZodType {\n _parse(input) {\n const { status, ctx } = this._processInputParams(input);\n if (ctx.parsedType !== ZodParsedType.array) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.array,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n if (ctx.data.length < this._def.items.length) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n minimum: this._def.items.length,\n inclusive: true,\n exact: false,\n type: \"array\",\n });\n return INVALID;\n }\n const rest = this._def.rest;\n if (!rest && ctx.data.length > this._def.items.length) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n maximum: this._def.items.length,\n inclusive: true,\n exact: false,\n type: \"array\",\n });\n status.dirty();\n }\n const items = [...ctx.data]\n .map((item, itemIndex) => {\n const schema = this._def.items[itemIndex] || this._def.rest;\n if (!schema)\n return null;\n return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));\n })\n .filter((x) => !!x); // filter nulls\n if (ctx.common.async) {\n return Promise.all(items).then((results) => {\n return ParseStatus.mergeArray(status, results);\n });\n }\n else {\n return ParseStatus.mergeArray(status, items);\n }\n }\n get items() {\n return this._def.items;\n }\n rest(rest) {\n return new ZodTuple({\n ...this._def,\n rest,\n });\n }\n}\nZodTuple.create = (schemas, params) => {\n if (!Array.isArray(schemas)) {\n throw new Error(\"You must pass an array of schemas to z.tuple([ ... ])\");\n }\n return new ZodTuple({\n items: schemas,\n typeName: ZodFirstPartyTypeKind.ZodTuple,\n rest: null,\n ...processCreateParams(params),\n });\n};\nexport class ZodRecord extends ZodType {\n get keySchema() {\n return this._def.keyType;\n }\n get valueSchema() {\n return this._def.valueType;\n }\n _parse(input) {\n const { status, ctx } = this._processInputParams(input);\n if (ctx.parsedType !== ZodParsedType.object) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.object,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n const pairs = [];\n const keyType = this._def.keyType;\n const valueType = this._def.valueType;\n for (const key in ctx.data) {\n pairs.push({\n key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),\n value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),\n alwaysSet: key in ctx.data,\n });\n }\n if (ctx.common.async) {\n return ParseStatus.mergeObjectAsync(status, pairs);\n }\n else {\n return ParseStatus.mergeObjectSync(status, pairs);\n }\n }\n get element() {\n return this._def.valueType;\n }\n static create(first, second, third) {\n if (second instanceof ZodType) {\n return new ZodRecord({\n keyType: first,\n valueType: second,\n typeName: ZodFirstPartyTypeKind.ZodRecord,\n ...processCreateParams(third),\n });\n }\n return new ZodRecord({\n keyType: ZodString.create(),\n valueType: first,\n typeName: ZodFirstPartyTypeKind.ZodRecord,\n ...processCreateParams(second),\n });\n }\n}\nexport class ZodMap extends ZodType {\n get keySchema() {\n return this._def.keyType;\n }\n get valueSchema() {\n return this._def.valueType;\n }\n _parse(input) {\n const { status, ctx } = this._processInputParams(input);\n if (ctx.parsedType !== ZodParsedType.map) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.map,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n const keyType = this._def.keyType;\n const valueType = this._def.valueType;\n const pairs = [...ctx.data.entries()].map(([key, value], index) => {\n return {\n key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, \"key\"])),\n value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, \"value\"])),\n };\n });\n if (ctx.common.async) {\n const finalMap = new Map();\n return Promise.resolve().then(async () => {\n for (const pair of pairs) {\n const key = await pair.key;\n const value = await pair.value;\n if (key.status === \"aborted\" || value.status === \"aborted\") {\n return INVALID;\n }\n if (key.status === \"dirty\" || value.status === \"dirty\") {\n status.dirty();\n }\n finalMap.set(key.value, value.value);\n }\n return { status: status.value, value: finalMap };\n });\n }\n else {\n const finalMap = new Map();\n for (const pair of pairs) {\n const key = pair.key;\n const value = pair.value;\n if (key.status === \"aborted\" || value.status === \"aborted\") {\n return INVALID;\n }\n if (key.status === \"dirty\" || value.status === \"dirty\") {\n status.dirty();\n }\n finalMap.set(key.value, value.value);\n }\n return { status: status.value, value: finalMap };\n }\n }\n}\nZodMap.create = (keyType, valueType, params) => {\n return new ZodMap({\n valueType,\n keyType,\n typeName: ZodFirstPartyTypeKind.ZodMap,\n ...processCreateParams(params),\n });\n};\nexport class ZodSet extends ZodType {\n _parse(input) {\n const { status, ctx } = this._processInputParams(input);\n if (ctx.parsedType !== ZodParsedType.set) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.set,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n const def = this._def;\n if (def.minSize !== null) {\n if (ctx.data.size < def.minSize.value) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_small,\n minimum: def.minSize.value,\n type: \"set\",\n inclusive: true,\n exact: false,\n message: def.minSize.message,\n });\n status.dirty();\n }\n }\n if (def.maxSize !== null) {\n if (ctx.data.size > def.maxSize.value) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.too_big,\n maximum: def.maxSize.value,\n type: \"set\",\n inclusive: true,\n exact: false,\n message: def.maxSize.message,\n });\n status.dirty();\n }\n }\n const valueType = this._def.valueType;\n function finalizeSet(elements) {\n const parsedSet = new Set();\n for (const element of elements) {\n if (element.status === \"aborted\")\n return INVALID;\n if (element.status === \"dirty\")\n status.dirty();\n parsedSet.add(element.value);\n }\n return { status: status.value, value: parsedSet };\n }\n const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));\n if (ctx.common.async) {\n return Promise.all(elements).then((elements) => finalizeSet(elements));\n }\n else {\n return finalizeSet(elements);\n }\n }\n min(minSize, message) {\n return new ZodSet({\n ...this._def,\n minSize: { value: minSize, message: errorUtil.toString(message) },\n });\n }\n max(maxSize, message) {\n return new ZodSet({\n ...this._def,\n maxSize: { value: maxSize, message: errorUtil.toString(message) },\n });\n }\n size(size, message) {\n return this.min(size, message).max(size, message);\n }\n nonempty(message) {\n return this.min(1, message);\n }\n}\nZodSet.create = (valueType, params) => {\n return new ZodSet({\n valueType,\n minSize: null,\n maxSize: null,\n typeName: ZodFirstPartyTypeKind.ZodSet,\n ...processCreateParams(params),\n });\n};\nexport class ZodFunction extends ZodType {\n constructor() {\n super(...arguments);\n this.validate = this.implement;\n }\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n if (ctx.parsedType !== ZodParsedType.function) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.function,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n function makeArgsIssue(args, error) {\n return makeIssue({\n data: args,\n path: ctx.path,\n errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), defaultErrorMap].filter((x) => !!x),\n issueData: {\n code: ZodIssueCode.invalid_arguments,\n argumentsError: error,\n },\n });\n }\n function makeReturnsIssue(returns, error) {\n return makeIssue({\n data: returns,\n path: ctx.path,\n errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), defaultErrorMap].filter((x) => !!x),\n issueData: {\n code: ZodIssueCode.invalid_return_type,\n returnTypeError: error,\n },\n });\n }\n const params = { errorMap: ctx.common.contextualErrorMap };\n const fn = ctx.data;\n if (this._def.returns instanceof ZodPromise) {\n // Would love a way to avoid disabling this rule, but we need\n // an alias (using an arrow function was what caused 2651).\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n const me = this;\n return OK(async function (...args) {\n const error = new ZodError([]);\n const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {\n error.addIssue(makeArgsIssue(args, e));\n throw error;\n });\n const result = await Reflect.apply(fn, this, parsedArgs);\n const parsedReturns = await me._def.returns._def.type\n .parseAsync(result, params)\n .catch((e) => {\n error.addIssue(makeReturnsIssue(result, e));\n throw error;\n });\n return parsedReturns;\n });\n }\n else {\n // Would love a way to avoid disabling this rule, but we need\n // an alias (using an arrow function was what caused 2651).\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n const me = this;\n return OK(function (...args) {\n const parsedArgs = me._def.args.safeParse(args, params);\n if (!parsedArgs.success) {\n throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);\n }\n const result = Reflect.apply(fn, this, parsedArgs.data);\n const parsedReturns = me._def.returns.safeParse(result, params);\n if (!parsedReturns.success) {\n throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);\n }\n return parsedReturns.data;\n });\n }\n }\n parameters() {\n return this._def.args;\n }\n returnType() {\n return this._def.returns;\n }\n args(...items) {\n return new ZodFunction({\n ...this._def,\n args: ZodTuple.create(items).rest(ZodUnknown.create()),\n });\n }\n returns(returnType) {\n return new ZodFunction({\n ...this._def,\n returns: returnType,\n });\n }\n implement(func) {\n const validatedFunc = this.parse(func);\n return validatedFunc;\n }\n strictImplement(func) {\n const validatedFunc = this.parse(func);\n return validatedFunc;\n }\n static create(args, returns, params) {\n return new ZodFunction({\n args: (args ? args : ZodTuple.create([]).rest(ZodUnknown.create())),\n returns: returns || ZodUnknown.create(),\n typeName: ZodFirstPartyTypeKind.ZodFunction,\n ...processCreateParams(params),\n });\n }\n}\nexport class ZodLazy extends ZodType {\n get schema() {\n return this._def.getter();\n }\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n const lazySchema = this._def.getter();\n return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });\n }\n}\nZodLazy.create = (getter, params) => {\n return new ZodLazy({\n getter: getter,\n typeName: ZodFirstPartyTypeKind.ZodLazy,\n ...processCreateParams(params),\n });\n};\nexport class ZodLiteral extends ZodType {\n _parse(input) {\n if (input.data !== this._def.value) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n received: ctx.data,\n code: ZodIssueCode.invalid_literal,\n expected: this._def.value,\n });\n return INVALID;\n }\n return { status: \"valid\", value: input.data };\n }\n get value() {\n return this._def.value;\n }\n}\nZodLiteral.create = (value, params) => {\n return new ZodLiteral({\n value: value,\n typeName: ZodFirstPartyTypeKind.ZodLiteral,\n ...processCreateParams(params),\n });\n};\nfunction createZodEnum(values, params) {\n return new ZodEnum({\n values,\n typeName: ZodFirstPartyTypeKind.ZodEnum,\n ...processCreateParams(params),\n });\n}\nexport class ZodEnum extends ZodType {\n _parse(input) {\n if (typeof input.data !== \"string\") {\n const ctx = this._getOrReturnCtx(input);\n const expectedValues = this._def.values;\n addIssueToContext(ctx, {\n expected: util.joinValues(expectedValues),\n received: ctx.parsedType,\n code: ZodIssueCode.invalid_type,\n });\n return INVALID;\n }\n if (!this._cache) {\n this._cache = new Set(this._def.values);\n }\n if (!this._cache.has(input.data)) {\n const ctx = this._getOrReturnCtx(input);\n const expectedValues = this._def.values;\n addIssueToContext(ctx, {\n received: ctx.data,\n code: ZodIssueCode.invalid_enum_value,\n options: expectedValues,\n });\n return INVALID;\n }\n return OK(input.data);\n }\n get options() {\n return this._def.values;\n }\n get enum() {\n const enumValues = {};\n for (const val of this._def.values) {\n enumValues[val] = val;\n }\n return enumValues;\n }\n get Values() {\n const enumValues = {};\n for (const val of this._def.values) {\n enumValues[val] = val;\n }\n return enumValues;\n }\n get Enum() {\n const enumValues = {};\n for (const val of this._def.values) {\n enumValues[val] = val;\n }\n return enumValues;\n }\n extract(values, newDef = this._def) {\n return ZodEnum.create(values, {\n ...this._def,\n ...newDef,\n });\n }\n exclude(values, newDef = this._def) {\n return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {\n ...this._def,\n ...newDef,\n });\n }\n}\nZodEnum.create = createZodEnum;\nexport class ZodNativeEnum extends ZodType {\n _parse(input) {\n const nativeEnumValues = util.getValidEnumValues(this._def.values);\n const ctx = this._getOrReturnCtx(input);\n if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {\n const expectedValues = util.objectValues(nativeEnumValues);\n addIssueToContext(ctx, {\n expected: util.joinValues(expectedValues),\n received: ctx.parsedType,\n code: ZodIssueCode.invalid_type,\n });\n return INVALID;\n }\n if (!this._cache) {\n this._cache = new Set(util.getValidEnumValues(this._def.values));\n }\n if (!this._cache.has(input.data)) {\n const expectedValues = util.objectValues(nativeEnumValues);\n addIssueToContext(ctx, {\n received: ctx.data,\n code: ZodIssueCode.invalid_enum_value,\n options: expectedValues,\n });\n return INVALID;\n }\n return OK(input.data);\n }\n get enum() {\n return this._def.values;\n }\n}\nZodNativeEnum.create = (values, params) => {\n return new ZodNativeEnum({\n values: values,\n typeName: ZodFirstPartyTypeKind.ZodNativeEnum,\n ...processCreateParams(params),\n });\n};\nexport class ZodPromise extends ZodType {\n unwrap() {\n return this._def.type;\n }\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.promise,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);\n return OK(promisified.then((data) => {\n return this._def.type.parseAsync(data, {\n path: ctx.path,\n errorMap: ctx.common.contextualErrorMap,\n });\n }));\n }\n}\nZodPromise.create = (schema, params) => {\n return new ZodPromise({\n type: schema,\n typeName: ZodFirstPartyTypeKind.ZodPromise,\n ...processCreateParams(params),\n });\n};\nexport class ZodEffects extends ZodType {\n innerType() {\n return this._def.schema;\n }\n sourceType() {\n return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects\n ? this._def.schema.sourceType()\n : this._def.schema;\n }\n _parse(input) {\n const { status, ctx } = this._processInputParams(input);\n const effect = this._def.effect || null;\n const checkCtx = {\n addIssue: (arg) => {\n addIssueToContext(ctx, arg);\n if (arg.fatal) {\n status.abort();\n }\n else {\n status.dirty();\n }\n },\n get path() {\n return ctx.path;\n },\n };\n checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);\n if (effect.type === \"preprocess\") {\n const processed = effect.transform(ctx.data, checkCtx);\n if (ctx.common.async) {\n return Promise.resolve(processed).then(async (processed) => {\n if (status.value === \"aborted\")\n return INVALID;\n const result = await this._def.schema._parseAsync({\n data: processed,\n path: ctx.path,\n parent: ctx,\n });\n if (result.status === \"aborted\")\n return INVALID;\n if (result.status === \"dirty\")\n return DIRTY(result.value);\n if (status.value === \"dirty\")\n return DIRTY(result.value);\n return result;\n });\n }\n else {\n if (status.value === \"aborted\")\n return INVALID;\n const result = this._def.schema._parseSync({\n data: processed,\n path: ctx.path,\n parent: ctx,\n });\n if (result.status === \"aborted\")\n return INVALID;\n if (result.status === \"dirty\")\n return DIRTY(result.value);\n if (status.value === \"dirty\")\n return DIRTY(result.value);\n return result;\n }\n }\n if (effect.type === \"refinement\") {\n const executeRefinement = (acc) => {\n const result = effect.refinement(acc, checkCtx);\n if (ctx.common.async) {\n return Promise.resolve(result);\n }\n if (result instanceof Promise) {\n throw new Error(\"Async refinement encountered during synchronous parse operation. Use .parseAsync instead.\");\n }\n return acc;\n };\n if (ctx.common.async === false) {\n const inner = this._def.schema._parseSync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n });\n if (inner.status === \"aborted\")\n return INVALID;\n if (inner.status === \"dirty\")\n status.dirty();\n // return value is ignored\n executeRefinement(inner.value);\n return { status: status.value, value: inner.value };\n }\n else {\n return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {\n if (inner.status === \"aborted\")\n return INVALID;\n if (inner.status === \"dirty\")\n status.dirty();\n return executeRefinement(inner.value).then(() => {\n return { status: status.value, value: inner.value };\n });\n });\n }\n }\n if (effect.type === \"transform\") {\n if (ctx.common.async === false) {\n const base = this._def.schema._parseSync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n });\n if (!isValid(base))\n return INVALID;\n const result = effect.transform(base.value, checkCtx);\n if (result instanceof Promise) {\n throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);\n }\n return { status: status.value, value: result };\n }\n else {\n return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {\n if (!isValid(base))\n return INVALID;\n return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({\n status: status.value,\n value: result,\n }));\n });\n }\n }\n util.assertNever(effect);\n }\n}\nZodEffects.create = (schema, effect, params) => {\n return new ZodEffects({\n schema,\n typeName: ZodFirstPartyTypeKind.ZodEffects,\n effect,\n ...processCreateParams(params),\n });\n};\nZodEffects.createWithPreprocess = (preprocess, schema, params) => {\n return new ZodEffects({\n schema,\n effect: { type: \"preprocess\", transform: preprocess },\n typeName: ZodFirstPartyTypeKind.ZodEffects,\n ...processCreateParams(params),\n });\n};\nexport { ZodEffects as ZodTransformer };\nexport class ZodOptional extends ZodType {\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType === ZodParsedType.undefined) {\n return OK(undefined);\n }\n return this._def.innerType._parse(input);\n }\n unwrap() {\n return this._def.innerType;\n }\n}\nZodOptional.create = (type, params) => {\n return new ZodOptional({\n innerType: type,\n typeName: ZodFirstPartyTypeKind.ZodOptional,\n ...processCreateParams(params),\n });\n};\nexport class ZodNullable extends ZodType {\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType === ZodParsedType.null) {\n return OK(null);\n }\n return this._def.innerType._parse(input);\n }\n unwrap() {\n return this._def.innerType;\n }\n}\nZodNullable.create = (type, params) => {\n return new ZodNullable({\n innerType: type,\n typeName: ZodFirstPartyTypeKind.ZodNullable,\n ...processCreateParams(params),\n });\n};\nexport class ZodDefault extends ZodType {\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n let data = ctx.data;\n if (ctx.parsedType === ZodParsedType.undefined) {\n data = this._def.defaultValue();\n }\n return this._def.innerType._parse({\n data,\n path: ctx.path,\n parent: ctx,\n });\n }\n removeDefault() {\n return this._def.innerType;\n }\n}\nZodDefault.create = (type, params) => {\n return new ZodDefault({\n innerType: type,\n typeName: ZodFirstPartyTypeKind.ZodDefault,\n defaultValue: typeof params.default === \"function\" ? params.default : () => params.default,\n ...processCreateParams(params),\n });\n};\nexport class ZodCatch extends ZodType {\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n // newCtx is used to not collect issues from inner types in ctx\n const newCtx = {\n ...ctx,\n common: {\n ...ctx.common,\n issues: [],\n },\n };\n const result = this._def.innerType._parse({\n data: newCtx.data,\n path: newCtx.path,\n parent: {\n ...newCtx,\n },\n });\n if (isAsync(result)) {\n return result.then((result) => {\n return {\n status: \"valid\",\n value: result.status === \"valid\"\n ? result.value\n : this._def.catchValue({\n get error() {\n return new ZodError(newCtx.common.issues);\n },\n input: newCtx.data,\n }),\n };\n });\n }\n else {\n return {\n status: \"valid\",\n value: result.status === \"valid\"\n ? result.value\n : this._def.catchValue({\n get error() {\n return new ZodError(newCtx.common.issues);\n },\n input: newCtx.data,\n }),\n };\n }\n }\n removeCatch() {\n return this._def.innerType;\n }\n}\nZodCatch.create = (type, params) => {\n return new ZodCatch({\n innerType: type,\n typeName: ZodFirstPartyTypeKind.ZodCatch,\n catchValue: typeof params.catch === \"function\" ? params.catch : () => params.catch,\n ...processCreateParams(params),\n });\n};\nexport class ZodNaN extends ZodType {\n _parse(input) {\n const parsedType = this._getType(input);\n if (parsedType !== ZodParsedType.nan) {\n const ctx = this._getOrReturnCtx(input);\n addIssueToContext(ctx, {\n code: ZodIssueCode.invalid_type,\n expected: ZodParsedType.nan,\n received: ctx.parsedType,\n });\n return INVALID;\n }\n return { status: \"valid\", value: input.data };\n }\n}\nZodNaN.create = (params) => {\n return new ZodNaN({\n typeName: ZodFirstPartyTypeKind.ZodNaN,\n ...processCreateParams(params),\n });\n};\nexport const BRAND = Symbol(\"zod_brand\");\nexport class ZodBranded extends ZodType {\n _parse(input) {\n const { ctx } = this._processInputParams(input);\n const data = ctx.data;\n return this._def.type._parse({\n data,\n path: ctx.path,\n parent: ctx,\n });\n }\n unwrap() {\n return this._def.type;\n }\n}\nexport class ZodPipeline extends ZodType {\n _parse(input) {\n const { status, ctx } = this._processInputParams(input);\n if (ctx.common.async) {\n const handleAsync = async () => {\n const inResult = await this._def.in._parseAsync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n });\n if (inResult.status === \"aborted\")\n return INVALID;\n if (inResult.status === \"dirty\") {\n status.dirty();\n return DIRTY(inResult.value);\n }\n else {\n return this._def.out._parseAsync({\n data: inResult.value,\n path: ctx.path,\n parent: ctx,\n });\n }\n };\n return handleAsync();\n }\n else {\n const inResult = this._def.in._parseSync({\n data: ctx.data,\n path: ctx.path,\n parent: ctx,\n });\n if (inResult.status === \"aborted\")\n return INVALID;\n if (inResult.status === \"dirty\") {\n status.dirty();\n return {\n status: \"dirty\",\n value: inResult.value,\n };\n }\n else {\n return this._def.out._parseSync({\n data: inResult.value,\n path: ctx.path,\n parent: ctx,\n });\n }\n }\n }\n static create(a, b) {\n return new ZodPipeline({\n in: a,\n out: b,\n typeName: ZodFirstPartyTypeKind.ZodPipeline,\n });\n }\n}\nexport class ZodReadonly extends ZodType {\n _parse(input) {\n const result = this._def.innerType._parse(input);\n const freeze = (data) => {\n if (isValid(data)) {\n data.value = Object.freeze(data.value);\n }\n return data;\n };\n return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);\n }\n unwrap() {\n return this._def.innerType;\n }\n}\nZodReadonly.create = (type, params) => {\n return new ZodReadonly({\n innerType: type,\n typeName: ZodFirstPartyTypeKind.ZodReadonly,\n ...processCreateParams(params),\n });\n};\n////////////////////////////////////////\n////////////////////////////////////////\n////////// //////////\n////////// z.custom //////////\n////////// //////////\n////////////////////////////////////////\n////////////////////////////////////////\nfunction cleanParams(params, data) {\n const p = typeof params === \"function\" ? params(data) : typeof params === \"string\" ? { message: params } : params;\n const p2 = typeof p === \"string\" ? { message: p } : p;\n return p2;\n}\nexport function custom(check, _params = {}, \n/**\n * @deprecated\n *\n * Pass `fatal` into the params object instead:\n *\n * ```ts\n * z.string().custom((val) => val.length > 5, { fatal: false })\n * ```\n *\n */\nfatal) {\n if (check)\n return ZodAny.create().superRefine((data, ctx) => {\n const r = check(data);\n if (r instanceof Promise) {\n return r.then((r) => {\n if (!r) {\n const params = cleanParams(_params, data);\n const _fatal = params.fatal ?? fatal ?? true;\n ctx.addIssue({ code: \"custom\", ...params, fatal: _fatal });\n }\n });\n }\n if (!r) {\n const params = cleanParams(_params, data);\n const _fatal = params.fatal ?? fatal ?? true;\n ctx.addIssue({ code: \"custom\", ...params, fatal: _fatal });\n }\n return;\n });\n return ZodAny.create();\n}\nexport { ZodType as Schema, ZodType as ZodSchema };\nexport const late = {\n object: ZodObject.lazycreate,\n};\nexport var ZodFirstPartyTypeKind;\n(function (ZodFirstPartyTypeKind) {\n ZodFirstPartyTypeKind[\"ZodString\"] = \"ZodString\";\n ZodFirstPartyTypeKind[\"ZodNumber\"] = \"ZodNumber\";\n ZodFirstPartyTypeKind[\"ZodNaN\"] = \"ZodNaN\";\n ZodFirstPartyTypeKind[\"ZodBigInt\"] = \"ZodBigInt\";\n ZodFirstPartyTypeKind[\"ZodBoolean\"] = \"ZodBoolean\";\n ZodFirstPartyTypeKind[\"ZodDate\"] = \"ZodDate\";\n ZodFirstPartyTypeKind[\"ZodSymbol\"] = \"ZodSymbol\";\n ZodFirstPartyTypeKind[\"ZodUndefined\"] = \"ZodUndefined\";\n ZodFirstPartyTypeKind[\"ZodNull\"] = \"ZodNull\";\n ZodFirstPartyTypeKind[\"ZodAny\"] = \"ZodAny\";\n ZodFirstPartyTypeKind[\"ZodUnknown\"] = \"ZodUnknown\";\n ZodFirstPartyTypeKind[\"ZodNever\"] = \"ZodNever\";\n ZodFirstPartyTypeKind[\"ZodVoid\"] = \"ZodVoid\";\n ZodFirstPartyTypeKind[\"ZodArray\"] = \"ZodArray\";\n ZodFirstPartyTypeKind[\"ZodObject\"] = \"ZodObject\";\n ZodFirstPartyTypeKind[\"ZodUnion\"] = \"ZodUnion\";\n ZodFirstPartyTypeKind[\"ZodDiscriminatedUnion\"] = \"ZodDiscriminatedUnion\";\n ZodFirstPartyTypeKind[\"ZodIntersection\"] = \"ZodIntersection\";\n ZodFirstPartyTypeKind[\"ZodTuple\"] = \"ZodTuple\";\n ZodFirstPartyTypeKind[\"ZodRecord\"] = \"ZodRecord\";\n ZodFirstPartyTypeKind[\"ZodMap\"] = \"ZodMap\";\n ZodFirstPartyTypeKind[\"ZodSet\"] = \"ZodSet\";\n ZodFirstPartyTypeKind[\"ZodFunction\"] = \"ZodFunction\";\n ZodFirstPartyTypeKind[\"ZodLazy\"] = \"ZodLazy\";\n ZodFirstPartyTypeKind[\"ZodLiteral\"] = \"ZodLiteral\";\n ZodFirstPartyTypeKind[\"ZodEnum\"] = \"ZodEnum\";\n ZodFirstPartyTypeKind[\"ZodEffects\"] = \"ZodEffects\";\n ZodFirstPartyTypeKind[\"ZodNativeEnum\"] = \"ZodNativeEnum\";\n ZodFirstPartyTypeKind[\"ZodOptional\"] = \"ZodOptional\";\n ZodFirstPartyTypeKind[\"ZodNullable\"] = \"ZodNullable\";\n ZodFirstPartyTypeKind[\"ZodDefault\"] = \"ZodDefault\";\n ZodFirstPartyTypeKind[\"ZodCatch\"] = \"ZodCatch\";\n ZodFirstPartyTypeKind[\"ZodPromise\"] = \"ZodPromise\";\n ZodFirstPartyTypeKind[\"ZodBranded\"] = \"ZodBranded\";\n ZodFirstPartyTypeKind[\"ZodPipeline\"] = \"ZodPipeline\";\n ZodFirstPartyTypeKind[\"ZodReadonly\"] = \"ZodReadonly\";\n})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));\n// requires TS 4.4+\nclass Class {\n constructor(..._) { }\n}\nconst instanceOfType = (\n// const instanceOfType = any>(\ncls, params = {\n message: `Input not instance of ${cls.name}`,\n}) => custom((data) => data instanceof cls, params);\nconst stringType = ZodString.create;\nconst numberType = ZodNumber.create;\nconst nanType = ZodNaN.create;\nconst bigIntType = ZodBigInt.create;\nconst booleanType = ZodBoolean.create;\nconst dateType = ZodDate.create;\nconst symbolType = ZodSymbol.create;\nconst undefinedType = ZodUndefined.create;\nconst nullType = ZodNull.create;\nconst anyType = ZodAny.create;\nconst unknownType = ZodUnknown.create;\nconst neverType = ZodNever.create;\nconst voidType = ZodVoid.create;\nconst arrayType = ZodArray.create;\nconst objectType = ZodObject.create;\nconst strictObjectType = ZodObject.strictCreate;\nconst unionType = ZodUnion.create;\nconst discriminatedUnionType = ZodDiscriminatedUnion.create;\nconst intersectionType = ZodIntersection.create;\nconst tupleType = ZodTuple.create;\nconst recordType = ZodRecord.create;\nconst mapType = ZodMap.create;\nconst setType = ZodSet.create;\nconst functionType = ZodFunction.create;\nconst lazyType = ZodLazy.create;\nconst literalType = ZodLiteral.create;\nconst enumType = ZodEnum.create;\nconst nativeEnumType = ZodNativeEnum.create;\nconst promiseType = ZodPromise.create;\nconst effectsType = ZodEffects.create;\nconst optionalType = ZodOptional.create;\nconst nullableType = ZodNullable.create;\nconst preprocessType = ZodEffects.createWithPreprocess;\nconst pipelineType = ZodPipeline.create;\nconst ostring = () => stringType().optional();\nconst onumber = () => numberType().optional();\nconst oboolean = () => booleanType().optional();\nexport const coerce = {\n string: ((arg) => ZodString.create({ ...arg, coerce: true })),\n number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),\n boolean: ((arg) => ZodBoolean.create({\n ...arg,\n coerce: true,\n })),\n bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),\n date: ((arg) => ZodDate.create({ ...arg, coerce: true })),\n};\nexport { anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, dateType as date, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, instanceOfType as instanceof, intersectionType as intersection, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, oboolean, onumber, optionalType as optional, ostring, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, recordType as record, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, };\nexport const NEVER = INVALID;\n", "/** A special constant with type `never` */\nexport const NEVER = Object.freeze({\n status: \"aborted\",\n});\nexport /*@__NO_SIDE_EFFECTS__*/ function $constructor(name, initializer, params) {\n function init(inst, def) {\n if (!inst._zod) {\n Object.defineProperty(inst, \"_zod\", {\n value: {\n def,\n constr: _,\n traits: new Set(),\n },\n enumerable: false,\n });\n }\n if (inst._zod.traits.has(name)) {\n return;\n }\n inst._zod.traits.add(name);\n initializer(inst, def);\n // support prototype modifications\n const proto = _.prototype;\n const keys = Object.keys(proto);\n for (let i = 0; i < keys.length; i++) {\n const k = keys[i];\n if (!(k in inst)) {\n inst[k] = proto[k].bind(inst);\n }\n }\n }\n // doesn't work if Parent has a constructor with arguments\n const Parent = params?.Parent ?? Object;\n class Definition extends Parent {\n }\n Object.defineProperty(Definition, \"name\", { value: name });\n function _(def) {\n var _a;\n const inst = params?.Parent ? new Definition() : this;\n init(inst, def);\n (_a = inst._zod).deferred ?? (_a.deferred = []);\n for (const fn of inst._zod.deferred) {\n fn();\n }\n return inst;\n }\n Object.defineProperty(_, \"init\", { value: init });\n Object.defineProperty(_, Symbol.hasInstance, {\n value: (inst) => {\n if (params?.Parent && inst instanceof params.Parent)\n return true;\n return inst?._zod?.traits?.has(name);\n },\n });\n Object.defineProperty(_, \"name\", { value: name });\n return _;\n}\n////////////////////////////// UTILITIES ///////////////////////////////////////\nexport const $brand = Symbol(\"zod_brand\");\nexport class $ZodAsyncError extends Error {\n constructor() {\n super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);\n }\n}\nexport class $ZodEncodeError extends Error {\n constructor(name) {\n super(`Encountered unidirectional transform during encode: ${name}`);\n this.name = \"ZodEncodeError\";\n }\n}\nexport const globalConfig = {};\nexport function config(newConfig) {\n if (newConfig)\n Object.assign(globalConfig, newConfig);\n return globalConfig;\n}\n", "// functions\nexport function assertEqual(val) {\n return val;\n}\nexport function assertNotEqual(val) {\n return val;\n}\nexport function assertIs(_arg) { }\nexport function assertNever(_x) {\n throw new Error(\"Unexpected value in exhaustive check\");\n}\nexport function assert(_) { }\nexport function getEnumValues(entries) {\n const numericValues = Object.values(entries).filter((v) => typeof v === \"number\");\n const values = Object.entries(entries)\n .filter(([k, _]) => numericValues.indexOf(+k) === -1)\n .map(([_, v]) => v);\n return values;\n}\nexport function joinValues(array, separator = \"|\") {\n return array.map((val) => stringifyPrimitive(val)).join(separator);\n}\nexport function jsonStringifyReplacer(_, value) {\n if (typeof value === \"bigint\")\n return value.toString();\n return value;\n}\nexport function cached(getter) {\n const set = false;\n return {\n get value() {\n if (!set) {\n const value = getter();\n Object.defineProperty(this, \"value\", { value });\n return value;\n }\n throw new Error(\"cached value already set\");\n },\n };\n}\nexport function nullish(input) {\n return input === null || input === undefined;\n}\nexport function cleanRegex(source) {\n const start = source.startsWith(\"^\") ? 1 : 0;\n const end = source.endsWith(\"$\") ? source.length - 1 : source.length;\n return source.slice(start, end);\n}\nexport function floatSafeRemainder(val, step) {\n const valDecCount = (val.toString().split(\".\")[1] || \"\").length;\n const stepString = step.toString();\n let stepDecCount = (stepString.split(\".\")[1] || \"\").length;\n if (stepDecCount === 0 && /\\d?e-\\d?/.test(stepString)) {\n const match = stepString.match(/\\d?e-(\\d?)/);\n if (match?.[1]) {\n stepDecCount = Number.parseInt(match[1]);\n }\n }\n const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;\n const valInt = Number.parseInt(val.toFixed(decCount).replace(\".\", \"\"));\n const stepInt = Number.parseInt(step.toFixed(decCount).replace(\".\", \"\"));\n return (valInt % stepInt) / 10 ** decCount;\n}\nconst EVALUATING = Symbol(\"evaluating\");\nexport function defineLazy(object, key, getter) {\n let value = undefined;\n Object.defineProperty(object, key, {\n get() {\n if (value === EVALUATING) {\n // Circular reference detected, return undefined to break the cycle\n return undefined;\n }\n if (value === undefined) {\n value = EVALUATING;\n value = getter();\n }\n return value;\n },\n set(v) {\n Object.defineProperty(object, key, {\n value: v,\n // configurable: true,\n });\n // object[key] = v;\n },\n configurable: true,\n });\n}\nexport function objectClone(obj) {\n return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));\n}\nexport function assignProp(target, prop, value) {\n Object.defineProperty(target, prop, {\n value,\n writable: true,\n enumerable: true,\n configurable: true,\n });\n}\nexport function mergeDefs(...defs) {\n const mergedDescriptors = {};\n for (const def of defs) {\n const descriptors = Object.getOwnPropertyDescriptors(def);\n Object.assign(mergedDescriptors, descriptors);\n }\n return Object.defineProperties({}, mergedDescriptors);\n}\nexport function cloneDef(schema) {\n return mergeDefs(schema._zod.def);\n}\nexport function getElementAtPath(obj, path) {\n if (!path)\n return obj;\n return path.reduce((acc, key) => acc?.[key], obj);\n}\nexport function promiseAllObject(promisesObj) {\n const keys = Object.keys(promisesObj);\n const promises = keys.map((key) => promisesObj[key]);\n return Promise.all(promises).then((results) => {\n const resolvedObj = {};\n for (let i = 0; i < keys.length; i++) {\n resolvedObj[keys[i]] = results[i];\n }\n return resolvedObj;\n });\n}\nexport function randomString(length = 10) {\n const chars = \"abcdefghijklmnopqrstuvwxyz\";\n let str = \"\";\n for (let i = 0; i < length; i++) {\n str += chars[Math.floor(Math.random() * chars.length)];\n }\n return str;\n}\nexport function esc(str) {\n return JSON.stringify(str);\n}\nexport function slugify(input) {\n return input\n .toLowerCase()\n .trim()\n .replace(/[^\\w\\s-]/g, \"\")\n .replace(/[\\s_-]+/g, \"-\")\n .replace(/^-+|-+$/g, \"\");\n}\nexport const captureStackTrace = (\"captureStackTrace\" in Error ? Error.captureStackTrace : (..._args) => { });\nexport function isObject(data) {\n return typeof data === \"object\" && data !== null && !Array.isArray(data);\n}\nexport const allowsEval = cached(() => {\n // @ts-ignore\n if (typeof navigator !== \"undefined\" && navigator?.userAgent?.includes(\"Cloudflare\")) {\n return false;\n }\n try {\n const F = Function;\n new F(\"\");\n return true;\n }\n catch (_) {\n return false;\n }\n});\nexport function isPlainObject(o) {\n if (isObject(o) === false)\n return false;\n // modified constructor\n const ctor = o.constructor;\n if (ctor === undefined)\n return true;\n if (typeof ctor !== \"function\")\n return true;\n // modified prototype\n const prot = ctor.prototype;\n if (isObject(prot) === false)\n return false;\n // ctor doesn't have static `isPrototypeOf`\n if (Object.prototype.hasOwnProperty.call(prot, \"isPrototypeOf\") === false) {\n return false;\n }\n return true;\n}\nexport function shallowClone(o) {\n if (isPlainObject(o))\n return { ...o };\n if (Array.isArray(o))\n return [...o];\n return o;\n}\nexport function numKeys(data) {\n let keyCount = 0;\n for (const key in data) {\n if (Object.prototype.hasOwnProperty.call(data, key)) {\n keyCount++;\n }\n }\n return keyCount;\n}\nexport const getParsedType = (data) => {\n const t = typeof data;\n switch (t) {\n case \"undefined\":\n return \"undefined\";\n case \"string\":\n return \"string\";\n case \"number\":\n return Number.isNaN(data) ? \"nan\" : \"number\";\n case \"boolean\":\n return \"boolean\";\n case \"function\":\n return \"function\";\n case \"bigint\":\n return \"bigint\";\n case \"symbol\":\n return \"symbol\";\n case \"object\":\n if (Array.isArray(data)) {\n return \"array\";\n }\n if (data === null) {\n return \"null\";\n }\n if (data.then && typeof data.then === \"function\" && data.catch && typeof data.catch === \"function\") {\n return \"promise\";\n }\n if (typeof Map !== \"undefined\" && data instanceof Map) {\n return \"map\";\n }\n if (typeof Set !== \"undefined\" && data instanceof Set) {\n return \"set\";\n }\n if (typeof Date !== \"undefined\" && data instanceof Date) {\n return \"date\";\n }\n // @ts-ignore\n if (typeof File !== \"undefined\" && data instanceof File) {\n return \"file\";\n }\n return \"object\";\n default:\n throw new Error(`Unknown data type: ${t}`);\n }\n};\nexport const propertyKeyTypes = new Set([\"string\", \"number\", \"symbol\"]);\nexport const primitiveTypes = new Set([\"string\", \"number\", \"bigint\", \"boolean\", \"symbol\", \"undefined\"]);\nexport function escapeRegex(str) {\n return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n// zod-specific utils\nexport function clone(inst, def, params) {\n const cl = new inst._zod.constr(def ?? inst._zod.def);\n if (!def || params?.parent)\n cl._zod.parent = inst;\n return cl;\n}\nexport function normalizeParams(_params) {\n const params = _params;\n if (!params)\n return {};\n if (typeof params === \"string\")\n return { error: () => params };\n if (params?.message !== undefined) {\n if (params?.error !== undefined)\n throw new Error(\"Cannot specify both `message` and `error` params\");\n params.error = params.message;\n }\n delete params.message;\n if (typeof params.error === \"string\")\n return { ...params, error: () => params.error };\n return params;\n}\nexport function createTransparentProxy(getter) {\n let target;\n return new Proxy({}, {\n get(_, prop, receiver) {\n target ?? (target = getter());\n return Reflect.get(target, prop, receiver);\n },\n set(_, prop, value, receiver) {\n target ?? (target = getter());\n return Reflect.set(target, prop, value, receiver);\n },\n has(_, prop) {\n target ?? (target = getter());\n return Reflect.has(target, prop);\n },\n deleteProperty(_, prop) {\n target ?? (target = getter());\n return Reflect.deleteProperty(target, prop);\n },\n ownKeys(_) {\n target ?? (target = getter());\n return Reflect.ownKeys(target);\n },\n getOwnPropertyDescriptor(_, prop) {\n target ?? (target = getter());\n return Reflect.getOwnPropertyDescriptor(target, prop);\n },\n defineProperty(_, prop, descriptor) {\n target ?? (target = getter());\n return Reflect.defineProperty(target, prop, descriptor);\n },\n });\n}\nexport function stringifyPrimitive(value) {\n if (typeof value === \"bigint\")\n return value.toString() + \"n\";\n if (typeof value === \"string\")\n return `\"${value}\"`;\n return `${value}`;\n}\nexport function optionalKeys(shape) {\n return Object.keys(shape).filter((k) => {\n return shape[k]._zod.optin === \"optional\" && shape[k]._zod.optout === \"optional\";\n });\n}\nexport const NUMBER_FORMAT_RANGES = {\n safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],\n int32: [-2147483648, 2147483647],\n uint32: [0, 4294967295],\n float32: [-3.4028234663852886e38, 3.4028234663852886e38],\n float64: [-Number.MAX_VALUE, Number.MAX_VALUE],\n};\nexport const BIGINT_FORMAT_RANGES = {\n int64: [/* @__PURE__*/ BigInt(\"-9223372036854775808\"), /* @__PURE__*/ BigInt(\"9223372036854775807\")],\n uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt(\"18446744073709551615\")],\n};\nexport function pick(schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".pick() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const newShape = {};\n for (const key in mask) {\n if (!(key in currDef.shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n newShape[key] = currDef.shape[key];\n }\n assignProp(this, \"shape\", newShape); // self-caching\n return newShape;\n },\n checks: [],\n });\n return clone(schema, def);\n}\nexport function omit(schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".omit() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const newShape = { ...schema._zod.def.shape };\n for (const key in mask) {\n if (!(key in currDef.shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n delete newShape[key];\n }\n assignProp(this, \"shape\", newShape); // self-caching\n return newShape;\n },\n checks: [],\n });\n return clone(schema, def);\n}\nexport function extend(schema, shape) {\n if (!isPlainObject(shape)) {\n throw new Error(\"Invalid input to extend: expected a plain object\");\n }\n const checks = schema._zod.def.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n // Only throw if new shape overlaps with existing shape\n // Use getOwnPropertyDescriptor to check key existence without accessing values\n const existingShape = schema._zod.def.shape;\n for (const key in shape) {\n if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {\n throw new Error(\"Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.\");\n }\n }\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const _shape = { ...schema._zod.def.shape, ...shape };\n assignProp(this, \"shape\", _shape); // self-caching\n return _shape;\n },\n });\n return clone(schema, def);\n}\nexport function safeExtend(schema, shape) {\n if (!isPlainObject(shape)) {\n throw new Error(\"Invalid input to safeExtend: expected a plain object\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const _shape = { ...schema._zod.def.shape, ...shape };\n assignProp(this, \"shape\", _shape); // self-caching\n return _shape;\n },\n });\n return clone(schema, def);\n}\nexport function merge(a, b) {\n const def = mergeDefs(a._zod.def, {\n get shape() {\n const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };\n assignProp(this, \"shape\", _shape); // self-caching\n return _shape;\n },\n get catchall() {\n return b._zod.def.catchall;\n },\n checks: [], // delete existing checks\n });\n return clone(a, def);\n}\nexport function partial(Class, schema, mask) {\n const currDef = schema._zod.def;\n const checks = currDef.checks;\n const hasChecks = checks && checks.length > 0;\n if (hasChecks) {\n throw new Error(\".partial() cannot be used on object schemas containing refinements\");\n }\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const oldShape = schema._zod.def.shape;\n const shape = { ...oldShape };\n if (mask) {\n for (const key in mask) {\n if (!(key in oldShape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n // if (oldShape[key]!._zod.optin === \"optional\") continue;\n shape[key] = Class\n ? new Class({\n type: \"optional\",\n innerType: oldShape[key],\n })\n : oldShape[key];\n }\n }\n else {\n for (const key in oldShape) {\n // if (oldShape[key]!._zod.optin === \"optional\") continue;\n shape[key] = Class\n ? new Class({\n type: \"optional\",\n innerType: oldShape[key],\n })\n : oldShape[key];\n }\n }\n assignProp(this, \"shape\", shape); // self-caching\n return shape;\n },\n checks: [],\n });\n return clone(schema, def);\n}\nexport function required(Class, schema, mask) {\n const def = mergeDefs(schema._zod.def, {\n get shape() {\n const oldShape = schema._zod.def.shape;\n const shape = { ...oldShape };\n if (mask) {\n for (const key in mask) {\n if (!(key in shape)) {\n throw new Error(`Unrecognized key: \"${key}\"`);\n }\n if (!mask[key])\n continue;\n // overwrite with non-optional\n shape[key] = new Class({\n type: \"nonoptional\",\n innerType: oldShape[key],\n });\n }\n }\n else {\n for (const key in oldShape) {\n // overwrite with non-optional\n shape[key] = new Class({\n type: \"nonoptional\",\n innerType: oldShape[key],\n });\n }\n }\n assignProp(this, \"shape\", shape); // self-caching\n return shape;\n },\n });\n return clone(schema, def);\n}\n// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom\nexport function aborted(x, startIndex = 0) {\n if (x.aborted === true)\n return true;\n for (let i = startIndex; i < x.issues.length; i++) {\n if (x.issues[i]?.continue !== true) {\n return true;\n }\n }\n return false;\n}\nexport function prefixIssues(path, issues) {\n return issues.map((iss) => {\n var _a;\n (_a = iss).path ?? (_a.path = []);\n iss.path.unshift(path);\n return iss;\n });\n}\nexport function unwrapMessage(message) {\n return typeof message === \"string\" ? message : message?.message;\n}\nexport function finalizeIssue(iss, ctx, config) {\n const full = { ...iss, path: iss.path ?? [] };\n // for backwards compatibility\n if (!iss.message) {\n const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ??\n unwrapMessage(ctx?.error?.(iss)) ??\n unwrapMessage(config.customError?.(iss)) ??\n unwrapMessage(config.localeError?.(iss)) ??\n \"Invalid input\";\n full.message = message;\n }\n // delete (full as any).def;\n delete full.inst;\n delete full.continue;\n if (!ctx?.reportInput) {\n delete full.input;\n }\n return full;\n}\nexport function getSizableOrigin(input) {\n if (input instanceof Set)\n return \"set\";\n if (input instanceof Map)\n return \"map\";\n // @ts-ignore\n if (input instanceof File)\n return \"file\";\n return \"unknown\";\n}\nexport function getLengthableOrigin(input) {\n if (Array.isArray(input))\n return \"array\";\n if (typeof input === \"string\")\n return \"string\";\n return \"unknown\";\n}\nexport function parsedType(data) {\n const t = typeof data;\n switch (t) {\n case \"number\": {\n return Number.isNaN(data) ? \"nan\" : \"number\";\n }\n case \"object\": {\n if (data === null) {\n return \"null\";\n }\n if (Array.isArray(data)) {\n return \"array\";\n }\n const obj = data;\n if (obj && Object.getPrototypeOf(obj) !== Object.prototype && \"constructor\" in obj && obj.constructor) {\n return obj.constructor.name;\n }\n }\n }\n return t;\n}\nexport function issue(...args) {\n const [iss, input, inst] = args;\n if (typeof iss === \"string\") {\n return {\n message: iss,\n code: \"custom\",\n input,\n inst,\n };\n }\n return { ...iss };\n}\nexport function cleanEnum(obj) {\n return Object.entries(obj)\n .filter(([k, _]) => {\n // return true if NaN, meaning it's not a number, thus a string key\n return Number.isNaN(Number.parseInt(k, 10));\n })\n .map((el) => el[1]);\n}\n// Codec utility functions\nexport function base64ToUint8Array(base64) {\n const binaryString = atob(base64);\n const bytes = new Uint8Array(binaryString.length);\n for (let i = 0; i < binaryString.length; i++) {\n bytes[i] = binaryString.charCodeAt(i);\n }\n return bytes;\n}\nexport function uint8ArrayToBase64(bytes) {\n let binaryString = \"\";\n for (let i = 0; i < bytes.length; i++) {\n binaryString += String.fromCharCode(bytes[i]);\n }\n return btoa(binaryString);\n}\nexport function base64urlToUint8Array(base64url) {\n const base64 = base64url.replace(/-/g, \"+\").replace(/_/g, \"/\");\n const padding = \"=\".repeat((4 - (base64.length % 4)) % 4);\n return base64ToUint8Array(base64 + padding);\n}\nexport function uint8ArrayToBase64url(bytes) {\n return uint8ArrayToBase64(bytes).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=/g, \"\");\n}\nexport function hexToUint8Array(hex) {\n const cleanHex = hex.replace(/^0x/, \"\");\n if (cleanHex.length % 2 !== 0) {\n throw new Error(\"Invalid hex string length\");\n }\n const bytes = new Uint8Array(cleanHex.length / 2);\n for (let i = 0; i < cleanHex.length; i += 2) {\n bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);\n }\n return bytes;\n}\nexport function uint8ArrayToHex(bytes) {\n return Array.from(bytes)\n .map((b) => b.toString(16).padStart(2, \"0\"))\n .join(\"\");\n}\n// instanceof\nexport class Class {\n constructor(..._args) { }\n}\n", "import { $constructor } from \"./core.js\";\nimport * as util from \"./util.js\";\nconst initializer = (inst, def) => {\n inst.name = \"$ZodError\";\n Object.defineProperty(inst, \"_zod\", {\n value: inst._zod,\n enumerable: false,\n });\n Object.defineProperty(inst, \"issues\", {\n value: def,\n enumerable: false,\n });\n inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);\n Object.defineProperty(inst, \"toString\", {\n value: () => inst.message,\n enumerable: false,\n });\n};\nexport const $ZodError = $constructor(\"$ZodError\", initializer);\nexport const $ZodRealError = $constructor(\"$ZodError\", initializer, { Parent: Error });\nexport function flattenError(error, mapper = (issue) => issue.message) {\n const fieldErrors = {};\n const formErrors = [];\n for (const sub of error.issues) {\n if (sub.path.length > 0) {\n fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];\n fieldErrors[sub.path[0]].push(mapper(sub));\n }\n else {\n formErrors.push(mapper(sub));\n }\n }\n return { formErrors, fieldErrors };\n}\nexport function formatError(error, mapper = (issue) => issue.message) {\n const fieldErrors = { _errors: [] };\n const processError = (error) => {\n for (const issue of error.issues) {\n if (issue.code === \"invalid_union\" && issue.errors.length) {\n issue.errors.map((issues) => processError({ issues }));\n }\n else if (issue.code === \"invalid_key\") {\n processError({ issues: issue.issues });\n }\n else if (issue.code === \"invalid_element\") {\n processError({ issues: issue.issues });\n }\n else if (issue.path.length === 0) {\n fieldErrors._errors.push(mapper(issue));\n }\n else {\n let curr = fieldErrors;\n let i = 0;\n while (i < issue.path.length) {\n const el = issue.path[i];\n const terminal = i === issue.path.length - 1;\n if (!terminal) {\n curr[el] = curr[el] || { _errors: [] };\n }\n else {\n curr[el] = curr[el] || { _errors: [] };\n curr[el]._errors.push(mapper(issue));\n }\n curr = curr[el];\n i++;\n }\n }\n }\n };\n processError(error);\n return fieldErrors;\n}\nexport function treeifyError(error, mapper = (issue) => issue.message) {\n const result = { errors: [] };\n const processError = (error, path = []) => {\n var _a, _b;\n for (const issue of error.issues) {\n if (issue.code === \"invalid_union\" && issue.errors.length) {\n // regular union error\n issue.errors.map((issues) => processError({ issues }, issue.path));\n }\n else if (issue.code === \"invalid_key\") {\n processError({ issues: issue.issues }, issue.path);\n }\n else if (issue.code === \"invalid_element\") {\n processError({ issues: issue.issues }, issue.path);\n }\n else {\n const fullpath = [...path, ...issue.path];\n if (fullpath.length === 0) {\n result.errors.push(mapper(issue));\n continue;\n }\n let curr = result;\n let i = 0;\n while (i < fullpath.length) {\n const el = fullpath[i];\n const terminal = i === fullpath.length - 1;\n if (typeof el === \"string\") {\n curr.properties ?? (curr.properties = {});\n (_a = curr.properties)[el] ?? (_a[el] = { errors: [] });\n curr = curr.properties[el];\n }\n else {\n curr.items ?? (curr.items = []);\n (_b = curr.items)[el] ?? (_b[el] = { errors: [] });\n curr = curr.items[el];\n }\n if (terminal) {\n curr.errors.push(mapper(issue));\n }\n i++;\n }\n }\n }\n };\n processError(error);\n return result;\n}\n/** Format a ZodError as a human-readable string in the following form.\n *\n * From\n *\n * ```ts\n * ZodError {\n * issues: [\n * {\n * expected: 'string',\n * code: 'invalid_type',\n * path: [ 'username' ],\n * message: 'Invalid input: expected string'\n * },\n * {\n * expected: 'number',\n * code: 'invalid_type',\n * path: [ 'favoriteNumbers', 1 ],\n * message: 'Invalid input: expected number'\n * }\n * ];\n * }\n * ```\n *\n * to\n *\n * ```\n * username\n * \u2716 Expected number, received string at \"username\n * favoriteNumbers[0]\n * \u2716 Invalid input: expected number\n * ```\n */\nexport function toDotPath(_path) {\n const segs = [];\n const path = _path.map((seg) => (typeof seg === \"object\" ? seg.key : seg));\n for (const seg of path) {\n if (typeof seg === \"number\")\n segs.push(`[${seg}]`);\n else if (typeof seg === \"symbol\")\n segs.push(`[${JSON.stringify(String(seg))}]`);\n else if (/[^\\w$]/.test(seg))\n segs.push(`[${JSON.stringify(seg)}]`);\n else {\n if (segs.length)\n segs.push(\".\");\n segs.push(seg);\n }\n }\n return segs.join(\"\");\n}\nexport function prettifyError(error) {\n const lines = [];\n // sort by path length\n const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);\n // Process each issue\n for (const issue of issues) {\n lines.push(`\u2716 ${issue.message}`);\n if (issue.path?.length)\n lines.push(` \u2192 at ${toDotPath(issue.path)}`);\n }\n // Convert Map to formatted string\n return lines.join(\"\\n\");\n}\n", "import * as core from \"./core.js\";\nimport * as errors from \"./errors.js\";\nimport * as util from \"./util.js\";\nexport const _parse = (_Err) => (schema, value, _ctx, _params) => {\n const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };\n const result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise) {\n throw new core.$ZodAsyncError();\n }\n if (result.issues.length) {\n const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n util.captureStackTrace(e, _params?.callee);\n throw e;\n }\n return result.value;\n};\nexport const parse = /* @__PURE__*/ _parse(errors.$ZodRealError);\nexport const _parseAsync = (_Err) => async (schema, value, _ctx, params) => {\n const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };\n let result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise)\n result = await result;\n if (result.issues.length) {\n const e = new (params?.Err ?? _Err)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())));\n util.captureStackTrace(e, params?.callee);\n throw e;\n }\n return result.value;\n};\nexport const parseAsync = /* @__PURE__*/ _parseAsync(errors.$ZodRealError);\nexport const _safeParse = (_Err) => (schema, value, _ctx) => {\n const ctx = _ctx ? { ..._ctx, async: false } : { async: false };\n const result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise) {\n throw new core.$ZodAsyncError();\n }\n return result.issues.length\n ? {\n success: false,\n error: new (_Err ?? errors.$ZodError)(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),\n }\n : { success: true, data: result.value };\n};\nexport const safeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);\nexport const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };\n let result = schema._zod.run({ value, issues: [] }, ctx);\n if (result instanceof Promise)\n result = await result;\n return result.issues.length\n ? {\n success: false,\n error: new _Err(result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),\n }\n : { success: true, data: result.value };\n};\nexport const safeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);\nexport const _encode = (_Err) => (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _parse(_Err)(schema, value, ctx);\n};\nexport const encode = /* @__PURE__*/ _encode(errors.$ZodRealError);\nexport const _decode = (_Err) => (schema, value, _ctx) => {\n return _parse(_Err)(schema, value, _ctx);\n};\nexport const decode = /* @__PURE__*/ _decode(errors.$ZodRealError);\nexport const _encodeAsync = (_Err) => async (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _parseAsync(_Err)(schema, value, ctx);\n};\nexport const encodeAsync = /* @__PURE__*/ _encodeAsync(errors.$ZodRealError);\nexport const _decodeAsync = (_Err) => async (schema, value, _ctx) => {\n return _parseAsync(_Err)(schema, value, _ctx);\n};\nexport const decodeAsync = /* @__PURE__*/ _decodeAsync(errors.$ZodRealError);\nexport const _safeEncode = (_Err) => (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _safeParse(_Err)(schema, value, ctx);\n};\nexport const safeEncode = /* @__PURE__*/ _safeEncode(errors.$ZodRealError);\nexport const _safeDecode = (_Err) => (schema, value, _ctx) => {\n return _safeParse(_Err)(schema, value, _ctx);\n};\nexport const safeDecode = /* @__PURE__*/ _safeDecode(errors.$ZodRealError);\nexport const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {\n const ctx = _ctx ? Object.assign(_ctx, { direction: \"backward\" }) : { direction: \"backward\" };\n return _safeParseAsync(_Err)(schema, value, ctx);\n};\nexport const safeEncodeAsync = /* @__PURE__*/ _safeEncodeAsync(errors.$ZodRealError);\nexport const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {\n return _safeParseAsync(_Err)(schema, value, _ctx);\n};\nexport const safeDecodeAsync = /* @__PURE__*/ _safeDecodeAsync(errors.$ZodRealError);\n", "import * as util from \"./util.js\";\nexport const cuid = /^[cC][^\\s-]{8,}$/;\nexport const cuid2 = /^[0-9a-z]+$/;\nexport const ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;\nexport const xid = /^[0-9a-vA-V]{20}$/;\nexport const ksuid = /^[A-Za-z0-9]{27}$/;\nexport const nanoid = /^[a-zA-Z0-9_-]{21}$/;\n/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */\nexport const duration = /^P(?:(\\d+W)|(?!.*W)(?=\\d|T\\d)(\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+([.,]\\d+)?S)?)?)$/;\n/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */\nexport const extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\\d+Y)|(?:[-+]?\\d+[.,]\\d+Y$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:(?:[-+]?\\d+W)|(?:[-+]?\\d+[.,]\\d+W$))?(?:(?:[-+]?\\d+D)|(?:[-+]?\\d+[.,]\\d+D$))?(?:T(?=[\\d+-])(?:(?:[-+]?\\d+H)|(?:[-+]?\\d+[.,]\\d+H$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:[-+]?\\d+(?:[.,]\\d+)?S)?)??$/;\n/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */\nexport const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;\n/** Returns a regex for validating an RFC 9562/4122 UUID.\n *\n * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */\nexport const uuid = (version) => {\n if (!version)\n return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;\n return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);\n};\nexport const uuid4 = /*@__PURE__*/ uuid(4);\nexport const uuid6 = /*@__PURE__*/ uuid(6);\nexport const uuid7 = /*@__PURE__*/ uuid(7);\n/** Practical email validation */\nexport const email = /^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/;\n/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */\nexport const html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n/** The classic emailregex.com regex for RFC 5322-compliant emails */\nexport const rfc5322Email = /^(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/;\n/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */\nexport const unicodeEmail = /^[^\\s@\"]{1,64}@[^\\s@]{1,255}$/u;\nexport const idnEmail = unicodeEmail;\nexport const browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression\nconst _emoji = `^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$`;\nexport function emoji() {\n return new RegExp(_emoji, \"u\");\n}\nexport const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\nexport const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;\nexport const mac = (delimiter) => {\n const escapedDelim = util.escapeRegex(delimiter ?? \":\");\n return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);\n};\nexport const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/([0-9]|[1-2][0-9]|3[0-2])$/;\nexport const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\n// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript\nexport const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;\nexport const base64url = /^[A-Za-z0-9_-]*$/;\n// based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address\n// export const hostname: RegExp = /^([a-zA-Z0-9-]+\\.)*[a-zA-Z0-9-]+$/;\nexport const hostname = /^(?=.{1,253}\\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\\.?$/;\nexport const domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,}$/;\n// https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)\n// E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15\nexport const e164 = /^\\+[1-9]\\d{6,14}$/;\n// const dateSource = `((\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\\\d|30)|(02)-(0[1-9]|1\\\\d|2[0-8])))`;\nconst dateSource = `(?:(?:\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\\\d|30)|(?:02)-(?:0[1-9]|1\\\\d|2[0-8])))`;\nexport const date = /*@__PURE__*/ new RegExp(`^${dateSource}$`);\nfunction timeSource(args) {\n const hhmm = `(?:[01]\\\\d|2[0-3]):[0-5]\\\\d`;\n const regex = typeof args.precision === \"number\"\n ? args.precision === -1\n ? `${hhmm}`\n : args.precision === 0\n ? `${hhmm}:[0-5]\\\\d`\n : `${hhmm}:[0-5]\\\\d\\\\.\\\\d{${args.precision}}`\n : `${hhmm}(?::[0-5]\\\\d(?:\\\\.\\\\d+)?)?`;\n return regex;\n}\nexport function time(args) {\n return new RegExp(`^${timeSource(args)}$`);\n}\n// Adapted from https://stackoverflow.com/a/3143231\nexport function datetime(args) {\n const time = timeSource({ precision: args.precision });\n const opts = [\"Z\"];\n if (args.local)\n opts.push(\"\");\n // if (args.offset) opts.push(`([+-]\\\\d{2}:\\\\d{2})`);\n if (args.offset)\n opts.push(`([+-](?:[01]\\\\d|2[0-3]):[0-5]\\\\d)`);\n const timeRegex = `${time}(?:${opts.join(\"|\")})`;\n return new RegExp(`^${dateSource}T(?:${timeRegex})$`);\n}\nexport const string = (params) => {\n const regex = params ? `[\\\\s\\\\S]{${params?.minimum ?? 0},${params?.maximum ?? \"\"}}` : `[\\\\s\\\\S]*`;\n return new RegExp(`^${regex}$`);\n};\nexport const bigint = /^-?\\d+n?$/;\nexport const integer = /^-?\\d+$/;\nexport const number = /^-?\\d+(?:\\.\\d+)?$/;\nexport const boolean = /^(?:true|false)$/i;\nconst _null = /^null$/i;\nexport { _null as null };\nconst _undefined = /^undefined$/i;\nexport { _undefined as undefined };\n// regex for string with no uppercase letters\nexport const lowercase = /^[^A-Z]*$/;\n// regex for string with no lowercase letters\nexport const uppercase = /^[^a-z]*$/;\n// regex for hexadecimal strings (any length)\nexport const hex = /^[0-9a-fA-F]*$/;\n// Hash regexes for different algorithms and encodings\n// Helper function to create base64 regex with exact length and padding\nfunction fixedBase64(bodyLength, padding) {\n return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);\n}\n// Helper function to create base64url regex with exact length (no padding)\nfunction fixedBase64url(length) {\n return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);\n}\n// MD5 (16 bytes): base64 = 24 chars total (22 + \"==\")\nexport const md5_hex = /^[0-9a-fA-F]{32}$/;\nexport const md5_base64 = /*@__PURE__*/ fixedBase64(22, \"==\");\nexport const md5_base64url = /*@__PURE__*/ fixedBase64url(22);\n// SHA1 (20 bytes): base64 = 28 chars total (27 + \"=\")\nexport const sha1_hex = /^[0-9a-fA-F]{40}$/;\nexport const sha1_base64 = /*@__PURE__*/ fixedBase64(27, \"=\");\nexport const sha1_base64url = /*@__PURE__*/ fixedBase64url(27);\n// SHA256 (32 bytes): base64 = 44 chars total (43 + \"=\")\nexport const sha256_hex = /^[0-9a-fA-F]{64}$/;\nexport const sha256_base64 = /*@__PURE__*/ fixedBase64(43, \"=\");\nexport const sha256_base64url = /*@__PURE__*/ fixedBase64url(43);\n// SHA384 (48 bytes): base64 = 64 chars total (no padding)\nexport const sha384_hex = /^[0-9a-fA-F]{96}$/;\nexport const sha384_base64 = /*@__PURE__*/ fixedBase64(64, \"\");\nexport const sha384_base64url = /*@__PURE__*/ fixedBase64url(64);\n// SHA512 (64 bytes): base64 = 88 chars total (86 + \"==\")\nexport const sha512_hex = /^[0-9a-fA-F]{128}$/;\nexport const sha512_base64 = /*@__PURE__*/ fixedBase64(86, \"==\");\nexport const sha512_base64url = /*@__PURE__*/ fixedBase64url(86);\n", "// import { $ZodType } from \"./schemas.js\";\nimport * as core from \"./core.js\";\nimport * as regexes from \"./regexes.js\";\nimport * as util from \"./util.js\";\nexport const $ZodCheck = /*@__PURE__*/ core.$constructor(\"$ZodCheck\", (inst, def) => {\n var _a;\n inst._zod ?? (inst._zod = {});\n inst._zod.def = def;\n (_a = inst._zod).onattach ?? (_a.onattach = []);\n});\nconst numericOriginMap = {\n number: \"number\",\n bigint: \"bigint\",\n object: \"date\",\n};\nexport const $ZodCheckLessThan = /*@__PURE__*/ core.$constructor(\"$ZodCheckLessThan\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const origin = numericOriginMap[typeof def.value];\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;\n if (def.value < curr) {\n if (def.inclusive)\n bag.maximum = def.value;\n else\n bag.exclusiveMaximum = def.value;\n }\n });\n inst._zod.check = (payload) => {\n if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {\n return;\n }\n payload.issues.push({\n origin,\n code: \"too_big\",\n maximum: typeof def.value === \"object\" ? def.value.getTime() : def.value,\n input: payload.value,\n inclusive: def.inclusive,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckGreaterThan = /*@__PURE__*/ core.$constructor(\"$ZodCheckGreaterThan\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const origin = numericOriginMap[typeof def.value];\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;\n if (def.value > curr) {\n if (def.inclusive)\n bag.minimum = def.value;\n else\n bag.exclusiveMinimum = def.value;\n }\n });\n inst._zod.check = (payload) => {\n if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {\n return;\n }\n payload.issues.push({\n origin,\n code: \"too_small\",\n minimum: typeof def.value === \"object\" ? def.value.getTime() : def.value,\n input: payload.value,\n inclusive: def.inclusive,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckMultipleOf = \n/*@__PURE__*/ core.$constructor(\"$ZodCheckMultipleOf\", (inst, def) => {\n $ZodCheck.init(inst, def);\n inst._zod.onattach.push((inst) => {\n var _a;\n (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);\n });\n inst._zod.check = (payload) => {\n if (typeof payload.value !== typeof def.value)\n throw new Error(\"Cannot mix number and bigint in multiple_of check.\");\n const isMultiple = typeof payload.value === \"bigint\"\n ? payload.value % def.value === BigInt(0)\n : util.floatSafeRemainder(payload.value, def.value) === 0;\n if (isMultiple)\n return;\n payload.issues.push({\n origin: typeof payload.value,\n code: \"not_multiple_of\",\n divisor: def.value,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckNumberFormat = /*@__PURE__*/ core.$constructor(\"$ZodCheckNumberFormat\", (inst, def) => {\n $ZodCheck.init(inst, def); // no format checks\n def.format = def.format || \"float64\";\n const isInt = def.format?.includes(\"int\");\n const origin = isInt ? \"int\" : \"number\";\n const [minimum, maximum] = util.NUMBER_FORMAT_RANGES[def.format];\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.format = def.format;\n bag.minimum = minimum;\n bag.maximum = maximum;\n if (isInt)\n bag.pattern = regexes.integer;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n if (isInt) {\n if (!Number.isInteger(input)) {\n // invalid_format issue\n // payload.issues.push({\n // expected: def.format,\n // format: def.format,\n // code: \"invalid_format\",\n // input,\n // inst,\n // });\n // invalid_type issue\n payload.issues.push({\n expected: origin,\n format: def.format,\n code: \"invalid_type\",\n continue: false,\n input,\n inst,\n });\n return;\n // not_multiple_of issue\n // payload.issues.push({\n // code: \"not_multiple_of\",\n // origin: \"number\",\n // input,\n // inst,\n // divisor: 1,\n // });\n }\n if (!Number.isSafeInteger(input)) {\n if (input > 0) {\n // too_big\n payload.issues.push({\n input,\n code: \"too_big\",\n maximum: Number.MAX_SAFE_INTEGER,\n note: \"Integers must be within the safe integer range.\",\n inst,\n origin,\n inclusive: true,\n continue: !def.abort,\n });\n }\n else {\n // too_small\n payload.issues.push({\n input,\n code: \"too_small\",\n minimum: Number.MIN_SAFE_INTEGER,\n note: \"Integers must be within the safe integer range.\",\n inst,\n origin,\n inclusive: true,\n continue: !def.abort,\n });\n }\n return;\n }\n }\n if (input < minimum) {\n payload.issues.push({\n origin: \"number\",\n input,\n code: \"too_small\",\n minimum,\n inclusive: true,\n inst,\n continue: !def.abort,\n });\n }\n if (input > maximum) {\n payload.issues.push({\n origin: \"number\",\n input,\n code: \"too_big\",\n maximum,\n inclusive: true,\n inst,\n continue: !def.abort,\n });\n }\n };\n});\nexport const $ZodCheckBigIntFormat = /*@__PURE__*/ core.$constructor(\"$ZodCheckBigIntFormat\", (inst, def) => {\n $ZodCheck.init(inst, def); // no format checks\n const [minimum, maximum] = util.BIGINT_FORMAT_RANGES[def.format];\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.format = def.format;\n bag.minimum = minimum;\n bag.maximum = maximum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n if (input < minimum) {\n payload.issues.push({\n origin: \"bigint\",\n input,\n code: \"too_small\",\n minimum: minimum,\n inclusive: true,\n inst,\n continue: !def.abort,\n });\n }\n if (input > maximum) {\n payload.issues.push({\n origin: \"bigint\",\n input,\n code: \"too_big\",\n maximum,\n inclusive: true,\n inst,\n continue: !def.abort,\n });\n }\n };\n});\nexport const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor(\"$ZodCheckMaxSize\", (inst, def) => {\n var _a;\n $ZodCheck.init(inst, def);\n (_a = inst._zod.def).when ?? (_a.when = (payload) => {\n const val = payload.value;\n return !util.nullish(val) && val.size !== undefined;\n });\n inst._zod.onattach.push((inst) => {\n const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);\n if (def.maximum < curr)\n inst._zod.bag.maximum = def.maximum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const size = input.size;\n if (size <= def.maximum)\n return;\n payload.issues.push({\n origin: util.getSizableOrigin(input),\n code: \"too_big\",\n maximum: def.maximum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor(\"$ZodCheckMinSize\", (inst, def) => {\n var _a;\n $ZodCheck.init(inst, def);\n (_a = inst._zod.def).when ?? (_a.when = (payload) => {\n const val = payload.value;\n return !util.nullish(val) && val.size !== undefined;\n });\n inst._zod.onattach.push((inst) => {\n const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);\n if (def.minimum > curr)\n inst._zod.bag.minimum = def.minimum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const size = input.size;\n if (size >= def.minimum)\n return;\n payload.issues.push({\n origin: util.getSizableOrigin(input),\n code: \"too_small\",\n minimum: def.minimum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor(\"$ZodCheckSizeEquals\", (inst, def) => {\n var _a;\n $ZodCheck.init(inst, def);\n (_a = inst._zod.def).when ?? (_a.when = (payload) => {\n const val = payload.value;\n return !util.nullish(val) && val.size !== undefined;\n });\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.minimum = def.size;\n bag.maximum = def.size;\n bag.size = def.size;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const size = input.size;\n if (size === def.size)\n return;\n const tooBig = size > def.size;\n payload.issues.push({\n origin: util.getSizableOrigin(input),\n ...(tooBig ? { code: \"too_big\", maximum: def.size } : { code: \"too_small\", minimum: def.size }),\n inclusive: true,\n exact: true,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor(\"$ZodCheckMaxLength\", (inst, def) => {\n var _a;\n $ZodCheck.init(inst, def);\n (_a = inst._zod.def).when ?? (_a.when = (payload) => {\n const val = payload.value;\n return !util.nullish(val) && val.length !== undefined;\n });\n inst._zod.onattach.push((inst) => {\n const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);\n if (def.maximum < curr)\n inst._zod.bag.maximum = def.maximum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const length = input.length;\n if (length <= def.maximum)\n return;\n const origin = util.getLengthableOrigin(input);\n payload.issues.push({\n origin,\n code: \"too_big\",\n maximum: def.maximum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor(\"$ZodCheckMinLength\", (inst, def) => {\n var _a;\n $ZodCheck.init(inst, def);\n (_a = inst._zod.def).when ?? (_a.when = (payload) => {\n const val = payload.value;\n return !util.nullish(val) && val.length !== undefined;\n });\n inst._zod.onattach.push((inst) => {\n const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);\n if (def.minimum > curr)\n inst._zod.bag.minimum = def.minimum;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const length = input.length;\n if (length >= def.minimum)\n return;\n const origin = util.getLengthableOrigin(input);\n payload.issues.push({\n origin,\n code: \"too_small\",\n minimum: def.minimum,\n inclusive: true,\n input,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckLengthEquals = /*@__PURE__*/ core.$constructor(\"$ZodCheckLengthEquals\", (inst, def) => {\n var _a;\n $ZodCheck.init(inst, def);\n (_a = inst._zod.def).when ?? (_a.when = (payload) => {\n const val = payload.value;\n return !util.nullish(val) && val.length !== undefined;\n });\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.minimum = def.length;\n bag.maximum = def.length;\n bag.length = def.length;\n });\n inst._zod.check = (payload) => {\n const input = payload.value;\n const length = input.length;\n if (length === def.length)\n return;\n const origin = util.getLengthableOrigin(input);\n const tooBig = length > def.length;\n payload.issues.push({\n origin,\n ...(tooBig ? { code: \"too_big\", maximum: def.length } : { code: \"too_small\", minimum: def.length }),\n inclusive: true,\n exact: true,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckStringFormat = /*@__PURE__*/ core.$constructor(\"$ZodCheckStringFormat\", (inst, def) => {\n var _a, _b;\n $ZodCheck.init(inst, def);\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.format = def.format;\n if (def.pattern) {\n bag.patterns ?? (bag.patterns = new Set());\n bag.patterns.add(def.pattern);\n }\n });\n if (def.pattern)\n (_a = inst._zod).check ?? (_a.check = (payload) => {\n def.pattern.lastIndex = 0;\n if (def.pattern.test(payload.value))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: def.format,\n input: payload.value,\n ...(def.pattern ? { pattern: def.pattern.toString() } : {}),\n inst,\n continue: !def.abort,\n });\n });\n else\n (_b = inst._zod).check ?? (_b.check = () => { });\n});\nexport const $ZodCheckRegex = /*@__PURE__*/ core.$constructor(\"$ZodCheckRegex\", (inst, def) => {\n $ZodCheckStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n def.pattern.lastIndex = 0;\n if (def.pattern.test(payload.value))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"regex\",\n input: payload.value,\n pattern: def.pattern.toString(),\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckLowerCase = /*@__PURE__*/ core.$constructor(\"$ZodCheckLowerCase\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.lowercase);\n $ZodCheckStringFormat.init(inst, def);\n});\nexport const $ZodCheckUpperCase = /*@__PURE__*/ core.$constructor(\"$ZodCheckUpperCase\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.uppercase);\n $ZodCheckStringFormat.init(inst, def);\n});\nexport const $ZodCheckIncludes = /*@__PURE__*/ core.$constructor(\"$ZodCheckIncludes\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const escapedRegex = util.escapeRegex(def.includes);\n const pattern = new RegExp(typeof def.position === \"number\" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);\n def.pattern = pattern;\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.patterns ?? (bag.patterns = new Set());\n bag.patterns.add(pattern);\n });\n inst._zod.check = (payload) => {\n if (payload.value.includes(def.includes, def.position))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"includes\",\n includes: def.includes,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckStartsWith = /*@__PURE__*/ core.$constructor(\"$ZodCheckStartsWith\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const pattern = new RegExp(`^${util.escapeRegex(def.prefix)}.*`);\n def.pattern ?? (def.pattern = pattern);\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.patterns ?? (bag.patterns = new Set());\n bag.patterns.add(pattern);\n });\n inst._zod.check = (payload) => {\n if (payload.value.startsWith(def.prefix))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"starts_with\",\n prefix: def.prefix,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckEndsWith = /*@__PURE__*/ core.$constructor(\"$ZodCheckEndsWith\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const pattern = new RegExp(`.*${util.escapeRegex(def.suffix)}$`);\n def.pattern ?? (def.pattern = pattern);\n inst._zod.onattach.push((inst) => {\n const bag = inst._zod.bag;\n bag.patterns ?? (bag.patterns = new Set());\n bag.patterns.add(pattern);\n });\n inst._zod.check = (payload) => {\n if (payload.value.endsWith(def.suffix))\n return;\n payload.issues.push({\n origin: \"string\",\n code: \"invalid_format\",\n format: \"ends_with\",\n suffix: def.suffix,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\n///////////////////////////////////\n///// $ZodCheckProperty /////\n///////////////////////////////////\nfunction handleCheckPropertyResult(result, payload, property) {\n if (result.issues.length) {\n payload.issues.push(...util.prefixIssues(property, result.issues));\n }\n}\nexport const $ZodCheckProperty = /*@__PURE__*/ core.$constructor(\"$ZodCheckProperty\", (inst, def) => {\n $ZodCheck.init(inst, def);\n inst._zod.check = (payload) => {\n const result = def.schema._zod.run({\n value: payload.value[def.property],\n issues: [],\n }, {});\n if (result instanceof Promise) {\n return result.then((result) => handleCheckPropertyResult(result, payload, def.property));\n }\n handleCheckPropertyResult(result, payload, def.property);\n return;\n };\n});\nexport const $ZodCheckMimeType = /*@__PURE__*/ core.$constructor(\"$ZodCheckMimeType\", (inst, def) => {\n $ZodCheck.init(inst, def);\n const mimeSet = new Set(def.mime);\n inst._zod.onattach.push((inst) => {\n inst._zod.bag.mime = def.mime;\n });\n inst._zod.check = (payload) => {\n if (mimeSet.has(payload.value.type))\n return;\n payload.issues.push({\n code: \"invalid_value\",\n values: def.mime,\n input: payload.value.type,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCheckOverwrite = /*@__PURE__*/ core.$constructor(\"$ZodCheckOverwrite\", (inst, def) => {\n $ZodCheck.init(inst, def);\n inst._zod.check = (payload) => {\n payload.value = def.tx(payload.value);\n };\n});\n", "export class Doc {\n constructor(args = []) {\n this.content = [];\n this.indent = 0;\n if (this)\n this.args = args;\n }\n indented(fn) {\n this.indent += 1;\n fn(this);\n this.indent -= 1;\n }\n write(arg) {\n if (typeof arg === \"function\") {\n arg(this, { execution: \"sync\" });\n arg(this, { execution: \"async\" });\n return;\n }\n const content = arg;\n const lines = content.split(\"\\n\").filter((x) => x);\n const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));\n const dedented = lines.map((x) => x.slice(minIndent)).map((x) => \" \".repeat(this.indent * 2) + x);\n for (const line of dedented) {\n this.content.push(line);\n }\n }\n compile() {\n const F = Function;\n const args = this?.args;\n const content = this?.content ?? [``];\n const lines = [...content.map((x) => ` ${x}`)];\n // console.log(lines.join(\"\\n\"));\n return new F(...args, lines.join(\"\\n\"));\n }\n}\n", "export const version = {\n major: 4,\n minor: 3,\n patch: 6,\n};\n", "import * as checks from \"./checks.js\";\nimport * as core from \"./core.js\";\nimport { Doc } from \"./doc.js\";\nimport { parse, parseAsync, safeParse, safeParseAsync } from \"./parse.js\";\nimport * as regexes from \"./regexes.js\";\nimport * as util from \"./util.js\";\nimport { version } from \"./versions.js\";\nexport const $ZodType = /*@__PURE__*/ core.$constructor(\"$ZodType\", (inst, def) => {\n var _a;\n inst ?? (inst = {});\n inst._zod.def = def; // set _def property\n inst._zod.bag = inst._zod.bag || {}; // initialize _bag object\n inst._zod.version = version;\n const checks = [...(inst._zod.def.checks ?? [])];\n // if inst is itself a checks.$ZodCheck, run it as a check\n if (inst._zod.traits.has(\"$ZodCheck\")) {\n checks.unshift(inst);\n }\n for (const ch of checks) {\n for (const fn of ch._zod.onattach) {\n fn(inst);\n }\n }\n if (checks.length === 0) {\n // deferred initializer\n // inst._zod.parse is not yet defined\n (_a = inst._zod).deferred ?? (_a.deferred = []);\n inst._zod.deferred?.push(() => {\n inst._zod.run = inst._zod.parse;\n });\n }\n else {\n const runChecks = (payload, checks, ctx) => {\n let isAborted = util.aborted(payload);\n let asyncResult;\n for (const ch of checks) {\n if (ch._zod.def.when) {\n const shouldRun = ch._zod.def.when(payload);\n if (!shouldRun)\n continue;\n }\n else if (isAborted) {\n continue;\n }\n const currLen = payload.issues.length;\n const _ = ch._zod.check(payload);\n if (_ instanceof Promise && ctx?.async === false) {\n throw new core.$ZodAsyncError();\n }\n if (asyncResult || _ instanceof Promise) {\n asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {\n await _;\n const nextLen = payload.issues.length;\n if (nextLen === currLen)\n return;\n if (!isAborted)\n isAborted = util.aborted(payload, currLen);\n });\n }\n else {\n const nextLen = payload.issues.length;\n if (nextLen === currLen)\n continue;\n if (!isAborted)\n isAborted = util.aborted(payload, currLen);\n }\n }\n if (asyncResult) {\n return asyncResult.then(() => {\n return payload;\n });\n }\n return payload;\n };\n const handleCanaryResult = (canary, payload, ctx) => {\n // abort if the canary is aborted\n if (util.aborted(canary)) {\n canary.aborted = true;\n return canary;\n }\n // run checks first, then\n const checkResult = runChecks(payload, checks, ctx);\n if (checkResult instanceof Promise) {\n if (ctx.async === false)\n throw new core.$ZodAsyncError();\n return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));\n }\n return inst._zod.parse(checkResult, ctx);\n };\n inst._zod.run = (payload, ctx) => {\n if (ctx.skipChecks) {\n return inst._zod.parse(payload, ctx);\n }\n if (ctx.direction === \"backward\") {\n // run canary\n // initial pass (no checks)\n const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });\n if (canary instanceof Promise) {\n return canary.then((canary) => {\n return handleCanaryResult(canary, payload, ctx);\n });\n }\n return handleCanaryResult(canary, payload, ctx);\n }\n // forward\n const result = inst._zod.parse(payload, ctx);\n if (result instanceof Promise) {\n if (ctx.async === false)\n throw new core.$ZodAsyncError();\n return result.then((result) => runChecks(result, checks, ctx));\n }\n return runChecks(result, checks, ctx);\n };\n }\n // Lazy initialize ~standard to avoid creating objects for every schema\n util.defineLazy(inst, \"~standard\", () => ({\n validate: (value) => {\n try {\n const r = safeParse(inst, value);\n return r.success ? { value: r.data } : { issues: r.error?.issues };\n }\n catch (_) {\n return safeParseAsync(inst, value).then((r) => (r.success ? { value: r.data } : { issues: r.error?.issues }));\n }\n },\n vendor: \"zod\",\n version: 1,\n }));\n});\nexport { clone } from \"./util.js\";\nexport const $ZodString = /*@__PURE__*/ core.$constructor(\"$ZodString\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = [...(inst?._zod.bag?.patterns ?? [])].pop() ?? regexes.string(inst._zod.bag);\n inst._zod.parse = (payload, _) => {\n if (def.coerce)\n try {\n payload.value = String(payload.value);\n }\n catch (_) { }\n if (typeof payload.value === \"string\")\n return payload;\n payload.issues.push({\n expected: \"string\",\n code: \"invalid_type\",\n input: payload.value,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodStringFormat = /*@__PURE__*/ core.$constructor(\"$ZodStringFormat\", (inst, def) => {\n // check initialization must come first\n checks.$ZodCheckStringFormat.init(inst, def);\n $ZodString.init(inst, def);\n});\nexport const $ZodGUID = /*@__PURE__*/ core.$constructor(\"$ZodGUID\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.guid);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodUUID = /*@__PURE__*/ core.$constructor(\"$ZodUUID\", (inst, def) => {\n if (def.version) {\n const versionMap = {\n v1: 1,\n v2: 2,\n v3: 3,\n v4: 4,\n v5: 5,\n v6: 6,\n v7: 7,\n v8: 8,\n };\n const v = versionMap[def.version];\n if (v === undefined)\n throw new Error(`Invalid UUID version: \"${def.version}\"`);\n def.pattern ?? (def.pattern = regexes.uuid(v));\n }\n else\n def.pattern ?? (def.pattern = regexes.uuid());\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodEmail = /*@__PURE__*/ core.$constructor(\"$ZodEmail\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.email);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodURL = /*@__PURE__*/ core.$constructor(\"$ZodURL\", (inst, def) => {\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n try {\n // Trim whitespace from input\n const trimmed = payload.value.trim();\n // @ts-ignore\n const url = new URL(trimmed);\n if (def.hostname) {\n def.hostname.lastIndex = 0;\n if (!def.hostname.test(url.hostname)) {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"url\",\n note: \"Invalid hostname\",\n pattern: def.hostname.source,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n }\n }\n if (def.protocol) {\n def.protocol.lastIndex = 0;\n if (!def.protocol.test(url.protocol.endsWith(\":\") ? url.protocol.slice(0, -1) : url.protocol)) {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"url\",\n note: \"Invalid protocol\",\n pattern: def.protocol.source,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n }\n }\n // Set the output value based on normalize flag\n if (def.normalize) {\n // Use normalized URL\n payload.value = url.href;\n }\n else {\n // Preserve the original input (trimmed)\n payload.value = trimmed;\n }\n return;\n }\n catch (_) {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"url\",\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n }\n };\n});\nexport const $ZodEmoji = /*@__PURE__*/ core.$constructor(\"$ZodEmoji\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.emoji());\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodNanoID = /*@__PURE__*/ core.$constructor(\"$ZodNanoID\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.nanoid);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodCUID = /*@__PURE__*/ core.$constructor(\"$ZodCUID\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.cuid);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodCUID2 = /*@__PURE__*/ core.$constructor(\"$ZodCUID2\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.cuid2);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodULID = /*@__PURE__*/ core.$constructor(\"$ZodULID\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.ulid);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodXID = /*@__PURE__*/ core.$constructor(\"$ZodXID\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.xid);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodKSUID = /*@__PURE__*/ core.$constructor(\"$ZodKSUID\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.ksuid);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodISODateTime = /*@__PURE__*/ core.$constructor(\"$ZodISODateTime\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.datetime(def));\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodISODate = /*@__PURE__*/ core.$constructor(\"$ZodISODate\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.date);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodISOTime = /*@__PURE__*/ core.$constructor(\"$ZodISOTime\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.time(def));\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodISODuration = /*@__PURE__*/ core.$constructor(\"$ZodISODuration\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.duration);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodIPv4 = /*@__PURE__*/ core.$constructor(\"$ZodIPv4\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.ipv4);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.format = `ipv4`;\n});\nexport const $ZodIPv6 = /*@__PURE__*/ core.$constructor(\"$ZodIPv6\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.ipv6);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.format = `ipv6`;\n inst._zod.check = (payload) => {\n try {\n // @ts-ignore\n new URL(`http://[${payload.value}]`);\n // return;\n }\n catch {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"ipv6\",\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n }\n };\n});\nexport const $ZodMAC = /*@__PURE__*/ core.$constructor(\"$ZodMAC\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.mac(def.delimiter));\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.format = `mac`;\n});\nexport const $ZodCIDRv4 = /*@__PURE__*/ core.$constructor(\"$ZodCIDRv4\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.cidrv4);\n $ZodStringFormat.init(inst, def);\n});\nexport const $ZodCIDRv6 = /*@__PURE__*/ core.$constructor(\"$ZodCIDRv6\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.cidrv6); // not used for validation\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n const parts = payload.value.split(\"/\");\n try {\n if (parts.length !== 2)\n throw new Error();\n const [address, prefix] = parts;\n if (!prefix)\n throw new Error();\n const prefixNum = Number(prefix);\n if (`${prefixNum}` !== prefix)\n throw new Error();\n if (prefixNum < 0 || prefixNum > 128)\n throw new Error();\n // @ts-ignore\n new URL(`http://[${address}]`);\n }\n catch {\n payload.issues.push({\n code: \"invalid_format\",\n format: \"cidrv6\",\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n }\n };\n});\n////////////////////////////// ZodBase64 //////////////////////////////\nexport function isValidBase64(data) {\n if (data === \"\")\n return true;\n if (data.length % 4 !== 0)\n return false;\n try {\n // @ts-ignore\n atob(data);\n return true;\n }\n catch {\n return false;\n }\n}\nexport const $ZodBase64 = /*@__PURE__*/ core.$constructor(\"$ZodBase64\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.base64);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.contentEncoding = \"base64\";\n inst._zod.check = (payload) => {\n if (isValidBase64(payload.value))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: \"base64\",\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\n////////////////////////////// ZodBase64 //////////////////////////////\nexport function isValidBase64URL(data) {\n if (!regexes.base64url.test(data))\n return false;\n const base64 = data.replace(/[-_]/g, (c) => (c === \"-\" ? \"+\" : \"/\"));\n const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, \"=\");\n return isValidBase64(padded);\n}\nexport const $ZodBase64URL = /*@__PURE__*/ core.$constructor(\"$ZodBase64URL\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.base64url);\n $ZodStringFormat.init(inst, def);\n inst._zod.bag.contentEncoding = \"base64url\";\n inst._zod.check = (payload) => {\n if (isValidBase64URL(payload.value))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: \"base64url\",\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodE164 = /*@__PURE__*/ core.$constructor(\"$ZodE164\", (inst, def) => {\n def.pattern ?? (def.pattern = regexes.e164);\n $ZodStringFormat.init(inst, def);\n});\n////////////////////////////// ZodJWT //////////////////////////////\nexport function isValidJWT(token, algorithm = null) {\n try {\n const tokensParts = token.split(\".\");\n if (tokensParts.length !== 3)\n return false;\n const [header] = tokensParts;\n if (!header)\n return false;\n // @ts-ignore\n const parsedHeader = JSON.parse(atob(header));\n if (\"typ\" in parsedHeader && parsedHeader?.typ !== \"JWT\")\n return false;\n if (!parsedHeader.alg)\n return false;\n if (algorithm && (!(\"alg\" in parsedHeader) || parsedHeader.alg !== algorithm))\n return false;\n return true;\n }\n catch {\n return false;\n }\n}\nexport const $ZodJWT = /*@__PURE__*/ core.$constructor(\"$ZodJWT\", (inst, def) => {\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n if (isValidJWT(payload.value, def.alg))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: \"jwt\",\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodCustomStringFormat = /*@__PURE__*/ core.$constructor(\"$ZodCustomStringFormat\", (inst, def) => {\n $ZodStringFormat.init(inst, def);\n inst._zod.check = (payload) => {\n if (def.fn(payload.value))\n return;\n payload.issues.push({\n code: \"invalid_format\",\n format: def.format,\n input: payload.value,\n inst,\n continue: !def.abort,\n });\n };\n});\nexport const $ZodNumber = /*@__PURE__*/ core.$constructor(\"$ZodNumber\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = inst._zod.bag.pattern ?? regexes.number;\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce)\n try {\n payload.value = Number(payload.value);\n }\n catch (_) { }\n const input = payload.value;\n if (typeof input === \"number\" && !Number.isNaN(input) && Number.isFinite(input)) {\n return payload;\n }\n const received = typeof input === \"number\"\n ? Number.isNaN(input)\n ? \"NaN\"\n : !Number.isFinite(input)\n ? \"Infinity\"\n : undefined\n : undefined;\n payload.issues.push({\n expected: \"number\",\n code: \"invalid_type\",\n input,\n inst,\n ...(received ? { received } : {}),\n });\n return payload;\n };\n});\nexport const $ZodNumberFormat = /*@__PURE__*/ core.$constructor(\"$ZodNumberFormat\", (inst, def) => {\n checks.$ZodCheckNumberFormat.init(inst, def);\n $ZodNumber.init(inst, def); // no format checks\n});\nexport const $ZodBoolean = /*@__PURE__*/ core.$constructor(\"$ZodBoolean\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = regexes.boolean;\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce)\n try {\n payload.value = Boolean(payload.value);\n }\n catch (_) { }\n const input = payload.value;\n if (typeof input === \"boolean\")\n return payload;\n payload.issues.push({\n expected: \"boolean\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodBigInt = /*@__PURE__*/ core.$constructor(\"$ZodBigInt\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = regexes.bigint;\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce)\n try {\n payload.value = BigInt(payload.value);\n }\n catch (_) { }\n if (typeof payload.value === \"bigint\")\n return payload;\n payload.issues.push({\n expected: \"bigint\",\n code: \"invalid_type\",\n input: payload.value,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodBigIntFormat = /*@__PURE__*/ core.$constructor(\"$ZodBigIntFormat\", (inst, def) => {\n checks.$ZodCheckBigIntFormat.init(inst, def);\n $ZodBigInt.init(inst, def); // no format checks\n});\nexport const $ZodSymbol = /*@__PURE__*/ core.$constructor(\"$ZodSymbol\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (typeof input === \"symbol\")\n return payload;\n payload.issues.push({\n expected: \"symbol\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodUndefined = /*@__PURE__*/ core.$constructor(\"$ZodUndefined\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = regexes.undefined;\n inst._zod.values = new Set([undefined]);\n inst._zod.optin = \"optional\";\n inst._zod.optout = \"optional\";\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (typeof input === \"undefined\")\n return payload;\n payload.issues.push({\n expected: \"undefined\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodNull = /*@__PURE__*/ core.$constructor(\"$ZodNull\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.pattern = regexes.null;\n inst._zod.values = new Set([null]);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (input === null)\n return payload;\n payload.issues.push({\n expected: \"null\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodAny = /*@__PURE__*/ core.$constructor(\"$ZodAny\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload) => payload;\n});\nexport const $ZodUnknown = /*@__PURE__*/ core.$constructor(\"$ZodUnknown\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload) => payload;\n});\nexport const $ZodNever = /*@__PURE__*/ core.$constructor(\"$ZodNever\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n payload.issues.push({\n expected: \"never\",\n code: \"invalid_type\",\n input: payload.value,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodVoid = /*@__PURE__*/ core.$constructor(\"$ZodVoid\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (typeof input === \"undefined\")\n return payload;\n payload.issues.push({\n expected: \"void\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodDate = /*@__PURE__*/ core.$constructor(\"$ZodDate\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n if (def.coerce) {\n try {\n payload.value = new Date(payload.value);\n }\n catch (_err) { }\n }\n const input = payload.value;\n const isDate = input instanceof Date;\n const isValidDate = isDate && !Number.isNaN(input.getTime());\n if (isValidDate)\n return payload;\n payload.issues.push({\n expected: \"date\",\n code: \"invalid_type\",\n input,\n ...(isDate ? { received: \"Invalid Date\" } : {}),\n inst,\n });\n return payload;\n };\n});\nfunction handleArrayResult(result, final, index) {\n if (result.issues.length) {\n final.issues.push(...util.prefixIssues(index, result.issues));\n }\n final.value[index] = result.value;\n}\nexport const $ZodArray = /*@__PURE__*/ core.$constructor(\"$ZodArray\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!Array.isArray(input)) {\n payload.issues.push({\n expected: \"array\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n }\n payload.value = Array(input.length);\n const proms = [];\n for (let i = 0; i < input.length; i++) {\n const item = input[i];\n const result = def.element._zod.run({\n value: item,\n issues: [],\n }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result) => handleArrayResult(result, payload, i)));\n }\n else {\n handleArrayResult(result, payload, i);\n }\n }\n if (proms.length) {\n return Promise.all(proms).then(() => payload);\n }\n return payload; //handleArrayResultsAsync(parseResults, final);\n };\n});\nfunction handlePropertyResult(result, final, key, input, isOptionalOut) {\n if (result.issues.length) {\n // For optional-out schemas, ignore errors on absent keys\n if (isOptionalOut && !(key in input)) {\n return;\n }\n final.issues.push(...util.prefixIssues(key, result.issues));\n }\n if (result.value === undefined) {\n if (key in input) {\n final.value[key] = undefined;\n }\n }\n else {\n final.value[key] = result.value;\n }\n}\nfunction normalizeDef(def) {\n const keys = Object.keys(def.shape);\n for (const k of keys) {\n if (!def.shape?.[k]?._zod?.traits?.has(\"$ZodType\")) {\n throw new Error(`Invalid element at key \"${k}\": expected a Zod schema`);\n }\n }\n const okeys = util.optionalKeys(def.shape);\n return {\n ...def,\n keys,\n keySet: new Set(keys),\n numKeys: keys.length,\n optionalKeys: new Set(okeys),\n };\n}\nfunction handleCatchall(proms, input, payload, ctx, def, inst) {\n const unrecognized = [];\n // iterate over input keys\n const keySet = def.keySet;\n const _catchall = def.catchall._zod;\n const t = _catchall.def.type;\n const isOptionalOut = _catchall.optout === \"optional\";\n for (const key in input) {\n if (keySet.has(key))\n continue;\n if (t === \"never\") {\n unrecognized.push(key);\n continue;\n }\n const r = _catchall.run({ value: input[key], issues: [] }, ctx);\n if (r instanceof Promise) {\n proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));\n }\n else {\n handlePropertyResult(r, payload, key, input, isOptionalOut);\n }\n }\n if (unrecognized.length) {\n payload.issues.push({\n code: \"unrecognized_keys\",\n keys: unrecognized,\n input,\n inst,\n });\n }\n if (!proms.length)\n return payload;\n return Promise.all(proms).then(() => {\n return payload;\n });\n}\nexport const $ZodObject = /*@__PURE__*/ core.$constructor(\"$ZodObject\", (inst, def) => {\n // requires cast because technically $ZodObject doesn't extend\n $ZodType.init(inst, def);\n // const sh = def.shape;\n const desc = Object.getOwnPropertyDescriptor(def, \"shape\");\n if (!desc?.get) {\n const sh = def.shape;\n Object.defineProperty(def, \"shape\", {\n get: () => {\n const newSh = { ...sh };\n Object.defineProperty(def, \"shape\", {\n value: newSh,\n });\n return newSh;\n },\n });\n }\n const _normalized = util.cached(() => normalizeDef(def));\n util.defineLazy(inst._zod, \"propValues\", () => {\n const shape = def.shape;\n const propValues = {};\n for (const key in shape) {\n const field = shape[key]._zod;\n if (field.values) {\n propValues[key] ?? (propValues[key] = new Set());\n for (const v of field.values)\n propValues[key].add(v);\n }\n }\n return propValues;\n });\n const isObject = util.isObject;\n const catchall = def.catchall;\n let value;\n inst._zod.parse = (payload, ctx) => {\n value ?? (value = _normalized.value);\n const input = payload.value;\n if (!isObject(input)) {\n payload.issues.push({\n expected: \"object\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n }\n payload.value = {};\n const proms = [];\n const shape = value.shape;\n for (const key of value.keys) {\n const el = shape[key];\n const isOptionalOut = el._zod.optout === \"optional\";\n const r = el._zod.run({ value: input[key], issues: [] }, ctx);\n if (r instanceof Promise) {\n proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));\n }\n else {\n handlePropertyResult(r, payload, key, input, isOptionalOut);\n }\n }\n if (!catchall) {\n return proms.length ? Promise.all(proms).then(() => payload) : payload;\n }\n return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);\n };\n});\nexport const $ZodObjectJIT = /*@__PURE__*/ core.$constructor(\"$ZodObjectJIT\", (inst, def) => {\n // requires cast because technically $ZodObject doesn't extend\n $ZodObject.init(inst, def);\n const superParse = inst._zod.parse;\n const _normalized = util.cached(() => normalizeDef(def));\n const generateFastpass = (shape) => {\n const doc = new Doc([\"shape\", \"payload\", \"ctx\"]);\n const normalized = _normalized.value;\n const parseStr = (key) => {\n const k = util.esc(key);\n return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;\n };\n doc.write(`const input = payload.value;`);\n const ids = Object.create(null);\n let counter = 0;\n for (const key of normalized.keys) {\n ids[key] = `key_${counter++}`;\n }\n // A: preserve key order {\n doc.write(`const newResult = {};`);\n for (const key of normalized.keys) {\n const id = ids[key];\n const k = util.esc(key);\n const schema = shape[key];\n const isOptionalOut = schema?._zod?.optout === \"optional\";\n doc.write(`const ${id} = ${parseStr(key)};`);\n if (isOptionalOut) {\n // For optional-out schemas, ignore errors on absent keys\n doc.write(`\n if (${id}.issues.length) {\n if (${k} in input) {\n payload.issues = payload.issues.concat(${id}.issues.map(iss => ({\n ...iss,\n path: iss.path ? [${k}, ...iss.path] : [${k}]\n })));\n }\n }\n \n if (${id}.value === undefined) {\n if (${k} in input) {\n newResult[${k}] = undefined;\n }\n } else {\n newResult[${k}] = ${id}.value;\n }\n \n `);\n }\n else {\n doc.write(`\n if (${id}.issues.length) {\n payload.issues = payload.issues.concat(${id}.issues.map(iss => ({\n ...iss,\n path: iss.path ? [${k}, ...iss.path] : [${k}]\n })));\n }\n \n if (${id}.value === undefined) {\n if (${k} in input) {\n newResult[${k}] = undefined;\n }\n } else {\n newResult[${k}] = ${id}.value;\n }\n \n `);\n }\n }\n doc.write(`payload.value = newResult;`);\n doc.write(`return payload;`);\n const fn = doc.compile();\n return (payload, ctx) => fn(shape, payload, ctx);\n };\n let fastpass;\n const isObject = util.isObject;\n const jit = !core.globalConfig.jitless;\n const allowsEval = util.allowsEval;\n const fastEnabled = jit && allowsEval.value; // && !def.catchall;\n const catchall = def.catchall;\n let value;\n inst._zod.parse = (payload, ctx) => {\n value ?? (value = _normalized.value);\n const input = payload.value;\n if (!isObject(input)) {\n payload.issues.push({\n expected: \"object\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n }\n if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {\n // always synchronous\n if (!fastpass)\n fastpass = generateFastpass(def.shape);\n payload = fastpass(payload, ctx);\n if (!catchall)\n return payload;\n return handleCatchall([], input, payload, ctx, value, inst);\n }\n return superParse(payload, ctx);\n };\n});\nfunction handleUnionResults(results, final, inst, ctx) {\n for (const result of results) {\n if (result.issues.length === 0) {\n final.value = result.value;\n return final;\n }\n }\n const nonaborted = results.filter((r) => !util.aborted(r));\n if (nonaborted.length === 1) {\n final.value = nonaborted[0].value;\n return nonaborted[0];\n }\n final.issues.push({\n code: \"invalid_union\",\n input: final.value,\n inst,\n errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),\n });\n return final;\n}\nexport const $ZodUnion = /*@__PURE__*/ core.$constructor(\"$ZodUnion\", (inst, def) => {\n $ZodType.init(inst, def);\n util.defineLazy(inst._zod, \"optin\", () => def.options.some((o) => o._zod.optin === \"optional\") ? \"optional\" : undefined);\n util.defineLazy(inst._zod, \"optout\", () => def.options.some((o) => o._zod.optout === \"optional\") ? \"optional\" : undefined);\n util.defineLazy(inst._zod, \"values\", () => {\n if (def.options.every((o) => o._zod.values)) {\n return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));\n }\n return undefined;\n });\n util.defineLazy(inst._zod, \"pattern\", () => {\n if (def.options.every((o) => o._zod.pattern)) {\n const patterns = def.options.map((o) => o._zod.pattern);\n return new RegExp(`^(${patterns.map((p) => util.cleanRegex(p.source)).join(\"|\")})$`);\n }\n return undefined;\n });\n const single = def.options.length === 1;\n const first = def.options[0]._zod.run;\n inst._zod.parse = (payload, ctx) => {\n if (single) {\n return first(payload, ctx);\n }\n let async = false;\n const results = [];\n for (const option of def.options) {\n const result = option._zod.run({\n value: payload.value,\n issues: [],\n }, ctx);\n if (result instanceof Promise) {\n results.push(result);\n async = true;\n }\n else {\n if (result.issues.length === 0)\n return result;\n results.push(result);\n }\n }\n if (!async)\n return handleUnionResults(results, payload, inst, ctx);\n return Promise.all(results).then((results) => {\n return handleUnionResults(results, payload, inst, ctx);\n });\n };\n});\nfunction handleExclusiveUnionResults(results, final, inst, ctx) {\n const successes = results.filter((r) => r.issues.length === 0);\n if (successes.length === 1) {\n final.value = successes[0].value;\n return final;\n }\n if (successes.length === 0) {\n // No matches - same as regular union\n final.issues.push({\n code: \"invalid_union\",\n input: final.value,\n inst,\n errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),\n });\n }\n else {\n // Multiple matches - exclusive union failure\n final.issues.push({\n code: \"invalid_union\",\n input: final.value,\n inst,\n errors: [],\n inclusive: false,\n });\n }\n return final;\n}\nexport const $ZodXor = /*@__PURE__*/ core.$constructor(\"$ZodXor\", (inst, def) => {\n $ZodUnion.init(inst, def);\n def.inclusive = false;\n const single = def.options.length === 1;\n const first = def.options[0]._zod.run;\n inst._zod.parse = (payload, ctx) => {\n if (single) {\n return first(payload, ctx);\n }\n let async = false;\n const results = [];\n for (const option of def.options) {\n const result = option._zod.run({\n value: payload.value,\n issues: [],\n }, ctx);\n if (result instanceof Promise) {\n results.push(result);\n async = true;\n }\n else {\n results.push(result);\n }\n }\n if (!async)\n return handleExclusiveUnionResults(results, payload, inst, ctx);\n return Promise.all(results).then((results) => {\n return handleExclusiveUnionResults(results, payload, inst, ctx);\n });\n };\n});\nexport const $ZodDiscriminatedUnion = \n/*@__PURE__*/\ncore.$constructor(\"$ZodDiscriminatedUnion\", (inst, def) => {\n def.inclusive = false;\n $ZodUnion.init(inst, def);\n const _super = inst._zod.parse;\n util.defineLazy(inst._zod, \"propValues\", () => {\n const propValues = {};\n for (const option of def.options) {\n const pv = option._zod.propValues;\n if (!pv || Object.keys(pv).length === 0)\n throw new Error(`Invalid discriminated union option at index \"${def.options.indexOf(option)}\"`);\n for (const [k, v] of Object.entries(pv)) {\n if (!propValues[k])\n propValues[k] = new Set();\n for (const val of v) {\n propValues[k].add(val);\n }\n }\n }\n return propValues;\n });\n const disc = util.cached(() => {\n const opts = def.options;\n const map = new Map();\n for (const o of opts) {\n const values = o._zod.propValues?.[def.discriminator];\n if (!values || values.size === 0)\n throw new Error(`Invalid discriminated union option at index \"${def.options.indexOf(o)}\"`);\n for (const v of values) {\n if (map.has(v)) {\n throw new Error(`Duplicate discriminator value \"${String(v)}\"`);\n }\n map.set(v, o);\n }\n }\n return map;\n });\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!util.isObject(input)) {\n payload.issues.push({\n code: \"invalid_type\",\n expected: \"object\",\n input,\n inst,\n });\n return payload;\n }\n const opt = disc.value.get(input?.[def.discriminator]);\n if (opt) {\n return opt._zod.run(payload, ctx);\n }\n if (def.unionFallback) {\n return _super(payload, ctx);\n }\n // no matching discriminator\n payload.issues.push({\n code: \"invalid_union\",\n errors: [],\n note: \"No matching discriminator\",\n discriminator: def.discriminator,\n input,\n path: [def.discriminator],\n inst,\n });\n return payload;\n };\n});\nexport const $ZodIntersection = /*@__PURE__*/ core.$constructor(\"$ZodIntersection\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n const left = def.left._zod.run({ value: input, issues: [] }, ctx);\n const right = def.right._zod.run({ value: input, issues: [] }, ctx);\n const async = left instanceof Promise || right instanceof Promise;\n if (async) {\n return Promise.all([left, right]).then(([left, right]) => {\n return handleIntersectionResults(payload, left, right);\n });\n }\n return handleIntersectionResults(payload, left, right);\n };\n});\nfunction mergeValues(a, b) {\n // const aType = parse.t(a);\n // const bType = parse.t(b);\n if (a === b) {\n return { valid: true, data: a };\n }\n if (a instanceof Date && b instanceof Date && +a === +b) {\n return { valid: true, data: a };\n }\n if (util.isPlainObject(a) && util.isPlainObject(b)) {\n const bKeys = Object.keys(b);\n const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);\n const newObj = { ...a, ...b };\n for (const key of sharedKeys) {\n const sharedValue = mergeValues(a[key], b[key]);\n if (!sharedValue.valid) {\n return {\n valid: false,\n mergeErrorPath: [key, ...sharedValue.mergeErrorPath],\n };\n }\n newObj[key] = sharedValue.data;\n }\n return { valid: true, data: newObj };\n }\n if (Array.isArray(a) && Array.isArray(b)) {\n if (a.length !== b.length) {\n return { valid: false, mergeErrorPath: [] };\n }\n const newArray = [];\n for (let index = 0; index < a.length; index++) {\n const itemA = a[index];\n const itemB = b[index];\n const sharedValue = mergeValues(itemA, itemB);\n if (!sharedValue.valid) {\n return {\n valid: false,\n mergeErrorPath: [index, ...sharedValue.mergeErrorPath],\n };\n }\n newArray.push(sharedValue.data);\n }\n return { valid: true, data: newArray };\n }\n return { valid: false, mergeErrorPath: [] };\n}\nfunction handleIntersectionResults(result, left, right) {\n // Track which side(s) report each key as unrecognized\n const unrecKeys = new Map();\n let unrecIssue;\n for (const iss of left.issues) {\n if (iss.code === \"unrecognized_keys\") {\n unrecIssue ?? (unrecIssue = iss);\n for (const k of iss.keys) {\n if (!unrecKeys.has(k))\n unrecKeys.set(k, {});\n unrecKeys.get(k).l = true;\n }\n }\n else {\n result.issues.push(iss);\n }\n }\n for (const iss of right.issues) {\n if (iss.code === \"unrecognized_keys\") {\n for (const k of iss.keys) {\n if (!unrecKeys.has(k))\n unrecKeys.set(k, {});\n unrecKeys.get(k).r = true;\n }\n }\n else {\n result.issues.push(iss);\n }\n }\n // Report only keys unrecognized by BOTH sides\n const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);\n if (bothKeys.length && unrecIssue) {\n result.issues.push({ ...unrecIssue, keys: bothKeys });\n }\n if (util.aborted(result))\n return result;\n const merged = mergeValues(left.value, right.value);\n if (!merged.valid) {\n throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);\n }\n result.value = merged.data;\n return result;\n}\nexport const $ZodTuple = /*@__PURE__*/ core.$constructor(\"$ZodTuple\", (inst, def) => {\n $ZodType.init(inst, def);\n const items = def.items;\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!Array.isArray(input)) {\n payload.issues.push({\n input,\n inst,\n expected: \"tuple\",\n code: \"invalid_type\",\n });\n return payload;\n }\n payload.value = [];\n const proms = [];\n const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== \"optional\");\n const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;\n if (!def.rest) {\n const tooBig = input.length > items.length;\n const tooSmall = input.length < optStart - 1;\n if (tooBig || tooSmall) {\n payload.issues.push({\n ...(tooBig\n ? { code: \"too_big\", maximum: items.length, inclusive: true }\n : { code: \"too_small\", minimum: items.length }),\n input,\n inst,\n origin: \"array\",\n });\n return payload;\n }\n }\n let i = -1;\n for (const item of items) {\n i++;\n if (i >= input.length)\n if (i >= optStart)\n continue;\n const result = item._zod.run({\n value: input[i],\n issues: [],\n }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result) => handleTupleResult(result, payload, i)));\n }\n else {\n handleTupleResult(result, payload, i);\n }\n }\n if (def.rest) {\n const rest = input.slice(items.length);\n for (const el of rest) {\n i++;\n const result = def.rest._zod.run({\n value: el,\n issues: [],\n }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result) => handleTupleResult(result, payload, i)));\n }\n else {\n handleTupleResult(result, payload, i);\n }\n }\n }\n if (proms.length)\n return Promise.all(proms).then(() => payload);\n return payload;\n };\n});\nfunction handleTupleResult(result, final, index) {\n if (result.issues.length) {\n final.issues.push(...util.prefixIssues(index, result.issues));\n }\n final.value[index] = result.value;\n}\nexport const $ZodRecord = /*@__PURE__*/ core.$constructor(\"$ZodRecord\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!util.isPlainObject(input)) {\n payload.issues.push({\n expected: \"record\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n }\n const proms = [];\n const values = def.keyType._zod.values;\n if (values) {\n payload.value = {};\n const recordKeys = new Set();\n for (const key of values) {\n if (typeof key === \"string\" || typeof key === \"number\" || typeof key === \"symbol\") {\n recordKeys.add(typeof key === \"number\" ? key.toString() : key);\n const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result) => {\n if (result.issues.length) {\n payload.issues.push(...util.prefixIssues(key, result.issues));\n }\n payload.value[key] = result.value;\n }));\n }\n else {\n if (result.issues.length) {\n payload.issues.push(...util.prefixIssues(key, result.issues));\n }\n payload.value[key] = result.value;\n }\n }\n }\n let unrecognized;\n for (const key in input) {\n if (!recordKeys.has(key)) {\n unrecognized = unrecognized ?? [];\n unrecognized.push(key);\n }\n }\n if (unrecognized && unrecognized.length > 0) {\n payload.issues.push({\n code: \"unrecognized_keys\",\n input,\n inst,\n keys: unrecognized,\n });\n }\n }\n else {\n payload.value = {};\n for (const key of Reflect.ownKeys(input)) {\n if (key === \"__proto__\")\n continue;\n let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);\n if (keyResult instanceof Promise) {\n throw new Error(\"Async schemas not supported in object keys currently\");\n }\n // Numeric string fallback: if key is a numeric string and failed, retry with Number(key)\n // This handles z.number(), z.literal([1, 2, 3]), and unions containing numeric literals\n const checkNumericKey = typeof key === \"string\" && regexes.number.test(key) && keyResult.issues.length;\n if (checkNumericKey) {\n const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);\n if (retryResult instanceof Promise) {\n throw new Error(\"Async schemas not supported in object keys currently\");\n }\n if (retryResult.issues.length === 0) {\n keyResult = retryResult;\n }\n }\n if (keyResult.issues.length) {\n if (def.mode === \"loose\") {\n // Pass through unchanged\n payload.value[key] = input[key];\n }\n else {\n // Default \"strict\" behavior: error on invalid key\n payload.issues.push({\n code: \"invalid_key\",\n origin: \"record\",\n issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),\n input: key,\n path: [key],\n inst,\n });\n }\n continue;\n }\n const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result) => {\n if (result.issues.length) {\n payload.issues.push(...util.prefixIssues(key, result.issues));\n }\n payload.value[keyResult.value] = result.value;\n }));\n }\n else {\n if (result.issues.length) {\n payload.issues.push(...util.prefixIssues(key, result.issues));\n }\n payload.value[keyResult.value] = result.value;\n }\n }\n }\n if (proms.length) {\n return Promise.all(proms).then(() => payload);\n }\n return payload;\n };\n});\nexport const $ZodMap = /*@__PURE__*/ core.$constructor(\"$ZodMap\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!(input instanceof Map)) {\n payload.issues.push({\n expected: \"map\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n }\n const proms = [];\n payload.value = new Map();\n for (const [key, value] of input) {\n const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);\n const valueResult = def.valueType._zod.run({ value: value, issues: [] }, ctx);\n if (keyResult instanceof Promise || valueResult instanceof Promise) {\n proms.push(Promise.all([keyResult, valueResult]).then(([keyResult, valueResult]) => {\n handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);\n }));\n }\n else {\n handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);\n }\n }\n if (proms.length)\n return Promise.all(proms).then(() => payload);\n return payload;\n };\n});\nfunction handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {\n if (keyResult.issues.length) {\n if (util.propertyKeyTypes.has(typeof key)) {\n final.issues.push(...util.prefixIssues(key, keyResult.issues));\n }\n else {\n final.issues.push({\n code: \"invalid_key\",\n origin: \"map\",\n input,\n inst,\n issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),\n });\n }\n }\n if (valueResult.issues.length) {\n if (util.propertyKeyTypes.has(typeof key)) {\n final.issues.push(...util.prefixIssues(key, valueResult.issues));\n }\n else {\n final.issues.push({\n origin: \"map\",\n code: \"invalid_element\",\n input,\n inst,\n key: key,\n issues: valueResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),\n });\n }\n }\n final.value.set(keyResult.value, valueResult.value);\n}\nexport const $ZodSet = /*@__PURE__*/ core.$constructor(\"$ZodSet\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n const input = payload.value;\n if (!(input instanceof Set)) {\n payload.issues.push({\n input,\n inst,\n expected: \"set\",\n code: \"invalid_type\",\n });\n return payload;\n }\n const proms = [];\n payload.value = new Set();\n for (const item of input) {\n const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);\n if (result instanceof Promise) {\n proms.push(result.then((result) => handleSetResult(result, payload)));\n }\n else\n handleSetResult(result, payload);\n }\n if (proms.length)\n return Promise.all(proms).then(() => payload);\n return payload;\n };\n});\nfunction handleSetResult(result, final) {\n if (result.issues.length) {\n final.issues.push(...result.issues);\n }\n final.value.add(result.value);\n}\nexport const $ZodEnum = /*@__PURE__*/ core.$constructor(\"$ZodEnum\", (inst, def) => {\n $ZodType.init(inst, def);\n const values = util.getEnumValues(def.entries);\n const valuesSet = new Set(values);\n inst._zod.values = valuesSet;\n inst._zod.pattern = new RegExp(`^(${values\n .filter((k) => util.propertyKeyTypes.has(typeof k))\n .map((o) => (typeof o === \"string\" ? util.escapeRegex(o) : o.toString()))\n .join(\"|\")})$`);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (valuesSet.has(input)) {\n return payload;\n }\n payload.issues.push({\n code: \"invalid_value\",\n values,\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodLiteral = /*@__PURE__*/ core.$constructor(\"$ZodLiteral\", (inst, def) => {\n $ZodType.init(inst, def);\n if (def.values.length === 0) {\n throw new Error(\"Cannot create literal schema with no valid values\");\n }\n const values = new Set(def.values);\n inst._zod.values = values;\n inst._zod.pattern = new RegExp(`^(${def.values\n .map((o) => (typeof o === \"string\" ? util.escapeRegex(o) : o ? util.escapeRegex(o.toString()) : String(o)))\n .join(\"|\")})$`);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n if (values.has(input)) {\n return payload;\n }\n payload.issues.push({\n code: \"invalid_value\",\n values: def.values,\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodFile = /*@__PURE__*/ core.$constructor(\"$ZodFile\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n const input = payload.value;\n // @ts-ignore\n if (input instanceof File)\n return payload;\n payload.issues.push({\n expected: \"file\",\n code: \"invalid_type\",\n input,\n inst,\n });\n return payload;\n };\n});\nexport const $ZodTransform = /*@__PURE__*/ core.$constructor(\"$ZodTransform\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n throw new core.$ZodEncodeError(inst.constructor.name);\n }\n const _out = def.transform(payload.value, payload);\n if (ctx.async) {\n const output = _out instanceof Promise ? _out : Promise.resolve(_out);\n return output.then((output) => {\n payload.value = output;\n return payload;\n });\n }\n if (_out instanceof Promise) {\n throw new core.$ZodAsyncError();\n }\n payload.value = _out;\n return payload;\n };\n});\nfunction handleOptionalResult(result, input) {\n if (result.issues.length && input === undefined) {\n return { issues: [], value: undefined };\n }\n return result;\n}\nexport const $ZodOptional = /*@__PURE__*/ core.$constructor(\"$ZodOptional\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.optin = \"optional\";\n inst._zod.optout = \"optional\";\n util.defineLazy(inst._zod, \"values\", () => {\n return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;\n });\n util.defineLazy(inst._zod, \"pattern\", () => {\n const pattern = def.innerType._zod.pattern;\n return pattern ? new RegExp(`^(${util.cleanRegex(pattern.source)})?$`) : undefined;\n });\n inst._zod.parse = (payload, ctx) => {\n if (def.innerType._zod.optin === \"optional\") {\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise)\n return result.then((r) => handleOptionalResult(r, payload.value));\n return handleOptionalResult(result, payload.value);\n }\n if (payload.value === undefined) {\n return payload;\n }\n return def.innerType._zod.run(payload, ctx);\n };\n});\nexport const $ZodExactOptional = /*@__PURE__*/ core.$constructor(\"$ZodExactOptional\", (inst, def) => {\n // Call parent init - inherits optin/optout = \"optional\"\n $ZodOptional.init(inst, def);\n // Override values/pattern to NOT add undefined\n util.defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n util.defineLazy(inst._zod, \"pattern\", () => def.innerType._zod.pattern);\n // Override parse to just delegate (no undefined handling)\n inst._zod.parse = (payload, ctx) => {\n return def.innerType._zod.run(payload, ctx);\n };\n});\nexport const $ZodNullable = /*@__PURE__*/ core.$constructor(\"$ZodNullable\", (inst, def) => {\n $ZodType.init(inst, def);\n util.defineLazy(inst._zod, \"optin\", () => def.innerType._zod.optin);\n util.defineLazy(inst._zod, \"optout\", () => def.innerType._zod.optout);\n util.defineLazy(inst._zod, \"pattern\", () => {\n const pattern = def.innerType._zod.pattern;\n return pattern ? new RegExp(`^(${util.cleanRegex(pattern.source)}|null)$`) : undefined;\n });\n util.defineLazy(inst._zod, \"values\", () => {\n return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;\n });\n inst._zod.parse = (payload, ctx) => {\n // Forward direction (decode): allow null to pass through\n if (payload.value === null)\n return payload;\n return def.innerType._zod.run(payload, ctx);\n };\n});\nexport const $ZodDefault = /*@__PURE__*/ core.$constructor(\"$ZodDefault\", (inst, def) => {\n $ZodType.init(inst, def);\n // inst._zod.qin = \"true\";\n inst._zod.optin = \"optional\";\n util.defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n // Forward direction (decode): apply defaults for undefined input\n if (payload.value === undefined) {\n payload.value = def.defaultValue;\n /**\n * $ZodDefault returns the default value immediately in forward direction.\n * It doesn't pass the default value into the validator (\"prefault\"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a \"prefault\" for the pipe. */\n return payload;\n }\n // Forward direction: continue with default handling\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result) => handleDefaultResult(result, def));\n }\n return handleDefaultResult(result, def);\n };\n});\nfunction handleDefaultResult(payload, def) {\n if (payload.value === undefined) {\n payload.value = def.defaultValue;\n }\n return payload;\n}\nexport const $ZodPrefault = /*@__PURE__*/ core.$constructor(\"$ZodPrefault\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.optin = \"optional\";\n util.defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n // Forward direction (decode): apply prefault for undefined input\n if (payload.value === undefined) {\n payload.value = def.defaultValue;\n }\n return def.innerType._zod.run(payload, ctx);\n };\n});\nexport const $ZodNonOptional = /*@__PURE__*/ core.$constructor(\"$ZodNonOptional\", (inst, def) => {\n $ZodType.init(inst, def);\n util.defineLazy(inst._zod, \"values\", () => {\n const v = def.innerType._zod.values;\n return v ? new Set([...v].filter((x) => x !== undefined)) : undefined;\n });\n inst._zod.parse = (payload, ctx) => {\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result) => handleNonOptionalResult(result, inst));\n }\n return handleNonOptionalResult(result, inst);\n };\n});\nfunction handleNonOptionalResult(payload, inst) {\n if (!payload.issues.length && payload.value === undefined) {\n payload.issues.push({\n code: \"invalid_type\",\n expected: \"nonoptional\",\n input: payload.value,\n inst,\n });\n }\n return payload;\n}\nexport const $ZodSuccess = /*@__PURE__*/ core.$constructor(\"$ZodSuccess\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n throw new core.$ZodEncodeError(\"ZodSuccess\");\n }\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result) => {\n payload.value = result.issues.length === 0;\n return payload;\n });\n }\n payload.value = result.issues.length === 0;\n return payload;\n };\n});\nexport const $ZodCatch = /*@__PURE__*/ core.$constructor(\"$ZodCatch\", (inst, def) => {\n $ZodType.init(inst, def);\n util.defineLazy(inst._zod, \"optin\", () => def.innerType._zod.optin);\n util.defineLazy(inst._zod, \"optout\", () => def.innerType._zod.optout);\n util.defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n // Forward direction (decode): apply catch logic\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then((result) => {\n payload.value = result.value;\n if (result.issues.length) {\n payload.value = def.catchValue({\n ...payload,\n error: {\n issues: result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),\n },\n input: payload.value,\n });\n payload.issues = [];\n }\n return payload;\n });\n }\n payload.value = result.value;\n if (result.issues.length) {\n payload.value = def.catchValue({\n ...payload,\n error: {\n issues: result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),\n },\n input: payload.value,\n });\n payload.issues = [];\n }\n return payload;\n };\n});\nexport const $ZodNaN = /*@__PURE__*/ core.$constructor(\"$ZodNaN\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _ctx) => {\n if (typeof payload.value !== \"number\" || !Number.isNaN(payload.value)) {\n payload.issues.push({\n input: payload.value,\n inst,\n expected: \"nan\",\n code: \"invalid_type\",\n });\n return payload;\n }\n return payload;\n };\n});\nexport const $ZodPipe = /*@__PURE__*/ core.$constructor(\"$ZodPipe\", (inst, def) => {\n $ZodType.init(inst, def);\n util.defineLazy(inst._zod, \"values\", () => def.in._zod.values);\n util.defineLazy(inst._zod, \"optin\", () => def.in._zod.optin);\n util.defineLazy(inst._zod, \"optout\", () => def.out._zod.optout);\n util.defineLazy(inst._zod, \"propValues\", () => def.in._zod.propValues);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n const right = def.out._zod.run(payload, ctx);\n if (right instanceof Promise) {\n return right.then((right) => handlePipeResult(right, def.in, ctx));\n }\n return handlePipeResult(right, def.in, ctx);\n }\n const left = def.in._zod.run(payload, ctx);\n if (left instanceof Promise) {\n return left.then((left) => handlePipeResult(left, def.out, ctx));\n }\n return handlePipeResult(left, def.out, ctx);\n };\n});\nfunction handlePipeResult(left, next, ctx) {\n if (left.issues.length) {\n // prevent further checks\n left.aborted = true;\n return left;\n }\n return next._zod.run({ value: left.value, issues: left.issues }, ctx);\n}\nexport const $ZodCodec = /*@__PURE__*/ core.$constructor(\"$ZodCodec\", (inst, def) => {\n $ZodType.init(inst, def);\n util.defineLazy(inst._zod, \"values\", () => def.in._zod.values);\n util.defineLazy(inst._zod, \"optin\", () => def.in._zod.optin);\n util.defineLazy(inst._zod, \"optout\", () => def.out._zod.optout);\n util.defineLazy(inst._zod, \"propValues\", () => def.in._zod.propValues);\n inst._zod.parse = (payload, ctx) => {\n const direction = ctx.direction || \"forward\";\n if (direction === \"forward\") {\n const left = def.in._zod.run(payload, ctx);\n if (left instanceof Promise) {\n return left.then((left) => handleCodecAResult(left, def, ctx));\n }\n return handleCodecAResult(left, def, ctx);\n }\n else {\n const right = def.out._zod.run(payload, ctx);\n if (right instanceof Promise) {\n return right.then((right) => handleCodecAResult(right, def, ctx));\n }\n return handleCodecAResult(right, def, ctx);\n }\n };\n});\nfunction handleCodecAResult(result, def, ctx) {\n if (result.issues.length) {\n // prevent further checks\n result.aborted = true;\n return result;\n }\n const direction = ctx.direction || \"forward\";\n if (direction === \"forward\") {\n const transformed = def.transform(result.value, result);\n if (transformed instanceof Promise) {\n return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));\n }\n return handleCodecTxResult(result, transformed, def.out, ctx);\n }\n else {\n const transformed = def.reverseTransform(result.value, result);\n if (transformed instanceof Promise) {\n return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));\n }\n return handleCodecTxResult(result, transformed, def.in, ctx);\n }\n}\nfunction handleCodecTxResult(left, value, nextSchema, ctx) {\n // Check if transform added any issues\n if (left.issues.length) {\n left.aborted = true;\n return left;\n }\n return nextSchema._zod.run({ value, issues: left.issues }, ctx);\n}\nexport const $ZodReadonly = /*@__PURE__*/ core.$constructor(\"$ZodReadonly\", (inst, def) => {\n $ZodType.init(inst, def);\n util.defineLazy(inst._zod, \"propValues\", () => def.innerType._zod.propValues);\n util.defineLazy(inst._zod, \"values\", () => def.innerType._zod.values);\n util.defineLazy(inst._zod, \"optin\", () => def.innerType?._zod?.optin);\n util.defineLazy(inst._zod, \"optout\", () => def.innerType?._zod?.optout);\n inst._zod.parse = (payload, ctx) => {\n if (ctx.direction === \"backward\") {\n return def.innerType._zod.run(payload, ctx);\n }\n const result = def.innerType._zod.run(payload, ctx);\n if (result instanceof Promise) {\n return result.then(handleReadonlyResult);\n }\n return handleReadonlyResult(result);\n };\n});\nfunction handleReadonlyResult(payload) {\n payload.value = Object.freeze(payload.value);\n return payload;\n}\nexport const $ZodTemplateLiteral = /*@__PURE__*/ core.$constructor(\"$ZodTemplateLiteral\", (inst, def) => {\n $ZodType.init(inst, def);\n const regexParts = [];\n for (const part of def.parts) {\n if (typeof part === \"object\" && part !== null) {\n // is Zod schema\n if (!part._zod.pattern) {\n // if (!source)\n throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);\n }\n const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;\n if (!source)\n throw new Error(`Invalid template literal part: ${part._zod.traits}`);\n const start = source.startsWith(\"^\") ? 1 : 0;\n const end = source.endsWith(\"$\") ? source.length - 1 : source.length;\n regexParts.push(source.slice(start, end));\n }\n else if (part === null || util.primitiveTypes.has(typeof part)) {\n regexParts.push(util.escapeRegex(`${part}`));\n }\n else {\n throw new Error(`Invalid template literal part: ${part}`);\n }\n }\n inst._zod.pattern = new RegExp(`^${regexParts.join(\"\")}$`);\n inst._zod.parse = (payload, _ctx) => {\n if (typeof payload.value !== \"string\") {\n payload.issues.push({\n input: payload.value,\n inst,\n expected: \"string\",\n code: \"invalid_type\",\n });\n return payload;\n }\n inst._zod.pattern.lastIndex = 0;\n if (!inst._zod.pattern.test(payload.value)) {\n payload.issues.push({\n input: payload.value,\n inst,\n code: \"invalid_format\",\n format: def.format ?? \"template_literal\",\n pattern: inst._zod.pattern.source,\n });\n return payload;\n }\n return payload;\n };\n});\nexport const $ZodFunction = /*@__PURE__*/ core.$constructor(\"$ZodFunction\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._def = def;\n inst._zod.def = def;\n inst.implement = (func) => {\n if (typeof func !== \"function\") {\n throw new Error(\"implement() must be called with a function\");\n }\n return function (...args) {\n const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;\n const result = Reflect.apply(func, this, parsedArgs);\n if (inst._def.output) {\n return parse(inst._def.output, result);\n }\n return result;\n };\n };\n inst.implementAsync = (func) => {\n if (typeof func !== \"function\") {\n throw new Error(\"implementAsync() must be called with a function\");\n }\n return async function (...args) {\n const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;\n const result = await Reflect.apply(func, this, parsedArgs);\n if (inst._def.output) {\n return await parseAsync(inst._def.output, result);\n }\n return result;\n };\n };\n inst._zod.parse = (payload, _ctx) => {\n if (typeof payload.value !== \"function\") {\n payload.issues.push({\n code: \"invalid_type\",\n expected: \"function\",\n input: payload.value,\n inst,\n });\n return payload;\n }\n // Check if output is a promise type to determine if we should use async implementation\n const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === \"promise\";\n if (hasPromiseOutput) {\n payload.value = inst.implementAsync(payload.value);\n }\n else {\n payload.value = inst.implement(payload.value);\n }\n return payload;\n };\n inst.input = (...args) => {\n const F = inst.constructor;\n if (Array.isArray(args[0])) {\n return new F({\n type: \"function\",\n input: new $ZodTuple({\n type: \"tuple\",\n items: args[0],\n rest: args[1],\n }),\n output: inst._def.output,\n });\n }\n return new F({\n type: \"function\",\n input: args[0],\n output: inst._def.output,\n });\n };\n inst.output = (output) => {\n const F = inst.constructor;\n return new F({\n type: \"function\",\n input: inst._def.input,\n output,\n });\n };\n return inst;\n});\nexport const $ZodPromise = /*@__PURE__*/ core.$constructor(\"$ZodPromise\", (inst, def) => {\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, ctx) => {\n return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));\n };\n});\nexport const $ZodLazy = /*@__PURE__*/ core.$constructor(\"$ZodLazy\", (inst, def) => {\n $ZodType.init(inst, def);\n // let _innerType!: any;\n // util.defineLazy(def, \"getter\", () => {\n // if (!_innerType) {\n // _innerType = def.getter();\n // }\n // return () => _innerType;\n // });\n util.defineLazy(inst._zod, \"innerType\", () => def.getter());\n util.defineLazy(inst._zod, \"pattern\", () => inst._zod.innerType?._zod?.pattern);\n util.defineLazy(inst._zod, \"propValues\", () => inst._zod.innerType?._zod?.propValues);\n util.defineLazy(inst._zod, \"optin\", () => inst._zod.innerType?._zod?.optin ?? undefined);\n util.defineLazy(inst._zod, \"optout\", () => inst._zod.innerType?._zod?.optout ?? undefined);\n inst._zod.parse = (payload, ctx) => {\n const inner = inst._zod.innerType;\n return inner._zod.run(payload, ctx);\n };\n});\nexport const $ZodCustom = /*@__PURE__*/ core.$constructor(\"$ZodCustom\", (inst, def) => {\n checks.$ZodCheck.init(inst, def);\n $ZodType.init(inst, def);\n inst._zod.parse = (payload, _) => {\n return payload;\n };\n inst._zod.check = (payload) => {\n const input = payload.value;\n const r = def.fn(input);\n if (r instanceof Promise) {\n return r.then((r) => handleRefineResult(r, payload, input, inst));\n }\n handleRefineResult(r, payload, input, inst);\n return;\n };\n});\nfunction handleRefineResult(result, payload, input, inst) {\n if (!result) {\n const _iss = {\n code: \"custom\",\n input,\n inst, // incorporates params.error into issue reporting\n path: [...(inst._zod.def.path ?? [])], // incorporates params.error into issue reporting\n continue: !inst._zod.def.abort,\n // params: inst._zod.def.params,\n };\n if (inst._zod.def.params)\n _iss.params = inst._zod.def.params;\n payload.issues.push(util.issue(_iss));\n }\n}\n", "import * as util from \"../core/util.js\";\nconst error = () => {\n const Sizable = {\n string: { unit: \"characters\", verb: \"to have\" },\n file: { unit: \"bytes\", verb: \"to have\" },\n array: { unit: \"items\", verb: \"to have\" },\n set: { unit: \"items\", verb: \"to have\" },\n map: { unit: \"entries\", verb: \"to have\" },\n };\n function getSizing(origin) {\n return Sizable[origin] ?? null;\n }\n const FormatDictionary = {\n regex: \"input\",\n email: \"email address\",\n url: \"URL\",\n emoji: \"emoji\",\n uuid: \"UUID\",\n uuidv4: \"UUIDv4\",\n uuidv6: \"UUIDv6\",\n nanoid: \"nanoid\",\n guid: \"GUID\",\n cuid: \"cuid\",\n cuid2: \"cuid2\",\n ulid: \"ULID\",\n xid: \"XID\",\n ksuid: \"KSUID\",\n datetime: \"ISO datetime\",\n date: \"ISO date\",\n time: \"ISO time\",\n duration: \"ISO duration\",\n ipv4: \"IPv4 address\",\n ipv6: \"IPv6 address\",\n mac: \"MAC address\",\n cidrv4: \"IPv4 range\",\n cidrv6: \"IPv6 range\",\n base64: \"base64-encoded string\",\n base64url: \"base64url-encoded string\",\n json_string: \"JSON string\",\n e164: \"E.164 number\",\n jwt: \"JWT\",\n template_literal: \"input\",\n };\n // type names: missing keys = do not translate (use raw value via ?? fallback)\n const TypeDictionary = {\n // Compatibility: \"nan\" -> \"NaN\" for display\n nan: \"NaN\",\n // All other type names omitted - they fall back to raw values via ?? operator\n };\n return (issue) => {\n switch (issue.code) {\n case \"invalid_type\": {\n const expected = TypeDictionary[issue.expected] ?? issue.expected;\n const receivedType = util.parsedType(issue.input);\n const received = TypeDictionary[receivedType] ?? receivedType;\n return `Invalid input: expected ${expected}, received ${received}`;\n }\n case \"invalid_value\":\n if (issue.values.length === 1)\n return `Invalid input: expected ${util.stringifyPrimitive(issue.values[0])}`;\n return `Invalid option: expected one of ${util.joinValues(issue.values, \"|\")}`;\n case \"too_big\": {\n const adj = issue.inclusive ? \"<=\" : \"<\";\n const sizing = getSizing(issue.origin);\n if (sizing)\n return `Too big: expected ${issue.origin ?? \"value\"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? \"elements\"}`;\n return `Too big: expected ${issue.origin ?? \"value\"} to be ${adj}${issue.maximum.toString()}`;\n }\n case \"too_small\": {\n const adj = issue.inclusive ? \">=\" : \">\";\n const sizing = getSizing(issue.origin);\n if (sizing) {\n return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;\n }\n return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;\n }\n case \"invalid_format\": {\n const _issue = issue;\n if (_issue.format === \"starts_with\") {\n return `Invalid string: must start with \"${_issue.prefix}\"`;\n }\n if (_issue.format === \"ends_with\")\n return `Invalid string: must end with \"${_issue.suffix}\"`;\n if (_issue.format === \"includes\")\n return `Invalid string: must include \"${_issue.includes}\"`;\n if (_issue.format === \"regex\")\n return `Invalid string: must match pattern ${_issue.pattern}`;\n return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;\n }\n case \"not_multiple_of\":\n return `Invalid number: must be a multiple of ${issue.divisor}`;\n case \"unrecognized_keys\":\n return `Unrecognized key${issue.keys.length > 1 ? \"s\" : \"\"}: ${util.joinValues(issue.keys, \", \")}`;\n case \"invalid_key\":\n return `Invalid key in ${issue.origin}`;\n case \"invalid_union\":\n return \"Invalid input\";\n case \"invalid_element\":\n return `Invalid value in ${issue.origin}`;\n default:\n return `Invalid input`;\n }\n };\n};\nexport default function () {\n return {\n localeError: error(),\n };\n}\n", "var _a;\nexport const $output = Symbol(\"ZodOutput\");\nexport const $input = Symbol(\"ZodInput\");\nexport class $ZodRegistry {\n constructor() {\n this._map = new WeakMap();\n this._idmap = new Map();\n }\n add(schema, ..._meta) {\n const meta = _meta[0];\n this._map.set(schema, meta);\n if (meta && typeof meta === \"object\" && \"id\" in meta) {\n this._idmap.set(meta.id, schema);\n }\n return this;\n }\n clear() {\n this._map = new WeakMap();\n this._idmap = new Map();\n return this;\n }\n remove(schema) {\n const meta = this._map.get(schema);\n if (meta && typeof meta === \"object\" && \"id\" in meta) {\n this._idmap.delete(meta.id);\n }\n this._map.delete(schema);\n return this;\n }\n get(schema) {\n // return this._map.get(schema) as any;\n // inherit metadata\n const p = schema._zod.parent;\n if (p) {\n const pm = { ...(this.get(p) ?? {}) };\n delete pm.id; // do not inherit id\n const f = { ...pm, ...this._map.get(schema) };\n return Object.keys(f).length ? f : undefined;\n }\n return this._map.get(schema);\n }\n has(schema) {\n return this._map.has(schema);\n }\n}\n// registries\nexport function registry() {\n return new $ZodRegistry();\n}\n(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());\nexport const globalRegistry = globalThis.__zod_globalRegistry;\n", "import * as checks from \"./checks.js\";\nimport * as registries from \"./registries.js\";\nimport * as schemas from \"./schemas.js\";\nimport * as util from \"./util.js\";\n// @__NO_SIDE_EFFECTS__\nexport function _string(Class, params) {\n return new Class({\n type: \"string\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedString(Class, params) {\n return new Class({\n type: \"string\",\n coerce: true,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _email(Class, params) {\n return new Class({\n type: \"string\",\n format: \"email\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _guid(Class, params) {\n return new Class({\n type: \"string\",\n format: \"guid\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuid(Class, params) {\n return new Class({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuidv4(Class, params) {\n return new Class({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n version: \"v4\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuidv6(Class, params) {\n return new Class({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n version: \"v6\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uuidv7(Class, params) {\n return new Class({\n type: \"string\",\n format: \"uuid\",\n check: \"string_format\",\n abort: false,\n version: \"v7\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _url(Class, params) {\n return new Class({\n type: \"string\",\n format: \"url\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _emoji(Class, params) {\n return new Class({\n type: \"string\",\n format: \"emoji\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nanoid(Class, params) {\n return new Class({\n type: \"string\",\n format: \"nanoid\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _cuid(Class, params) {\n return new Class({\n type: \"string\",\n format: \"cuid\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _cuid2(Class, params) {\n return new Class({\n type: \"string\",\n format: \"cuid2\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ulid(Class, params) {\n return new Class({\n type: \"string\",\n format: \"ulid\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _xid(Class, params) {\n return new Class({\n type: \"string\",\n format: \"xid\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ksuid(Class, params) {\n return new Class({\n type: \"string\",\n format: \"ksuid\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ipv4(Class, params) {\n return new Class({\n type: \"string\",\n format: \"ipv4\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _ipv6(Class, params) {\n return new Class({\n type: \"string\",\n format: \"ipv6\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _mac(Class, params) {\n return new Class({\n type: \"string\",\n format: \"mac\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _cidrv4(Class, params) {\n return new Class({\n type: \"string\",\n format: \"cidrv4\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _cidrv6(Class, params) {\n return new Class({\n type: \"string\",\n format: \"cidrv6\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _base64(Class, params) {\n return new Class({\n type: \"string\",\n format: \"base64\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _base64url(Class, params) {\n return new Class({\n type: \"string\",\n format: \"base64url\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _e164(Class, params) {\n return new Class({\n type: \"string\",\n format: \"e164\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _jwt(Class, params) {\n return new Class({\n type: \"string\",\n format: \"jwt\",\n check: \"string_format\",\n abort: false,\n ...util.normalizeParams(params),\n });\n}\nexport const TimePrecision = {\n Any: null,\n Minute: -1,\n Second: 0,\n Millisecond: 3,\n Microsecond: 6,\n};\n// @__NO_SIDE_EFFECTS__\nexport function _isoDateTime(Class, params) {\n return new Class({\n type: \"string\",\n format: \"datetime\",\n check: \"string_format\",\n offset: false,\n local: false,\n precision: null,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _isoDate(Class, params) {\n return new Class({\n type: \"string\",\n format: \"date\",\n check: \"string_format\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _isoTime(Class, params) {\n return new Class({\n type: \"string\",\n format: \"time\",\n check: \"string_format\",\n precision: null,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _isoDuration(Class, params) {\n return new Class({\n type: \"string\",\n format: \"duration\",\n check: \"string_format\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _number(Class, params) {\n return new Class({\n type: \"number\",\n checks: [],\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedNumber(Class, params) {\n return new Class({\n type: \"number\",\n coerce: true,\n checks: [],\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _int(Class, params) {\n return new Class({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"safeint\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _float32(Class, params) {\n return new Class({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"float32\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _float64(Class, params) {\n return new Class({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"float64\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _int32(Class, params) {\n return new Class({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"int32\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uint32(Class, params) {\n return new Class({\n type: \"number\",\n check: \"number_format\",\n abort: false,\n format: \"uint32\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _boolean(Class, params) {\n return new Class({\n type: \"boolean\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedBoolean(Class, params) {\n return new Class({\n type: \"boolean\",\n coerce: true,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _bigint(Class, params) {\n return new Class({\n type: \"bigint\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedBigint(Class, params) {\n return new Class({\n type: \"bigint\",\n coerce: true,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _int64(Class, params) {\n return new Class({\n type: \"bigint\",\n check: \"bigint_format\",\n abort: false,\n format: \"int64\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uint64(Class, params) {\n return new Class({\n type: \"bigint\",\n check: \"bigint_format\",\n abort: false,\n format: \"uint64\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _symbol(Class, params) {\n return new Class({\n type: \"symbol\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _undefined(Class, params) {\n return new Class({\n type: \"undefined\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _null(Class, params) {\n return new Class({\n type: \"null\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _any(Class) {\n return new Class({\n type: \"any\",\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _unknown(Class) {\n return new Class({\n type: \"unknown\",\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _never(Class, params) {\n return new Class({\n type: \"never\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _void(Class, params) {\n return new Class({\n type: \"void\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _date(Class, params) {\n return new Class({\n type: \"date\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _coercedDate(Class, params) {\n return new Class({\n type: \"date\",\n coerce: true,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nan(Class, params) {\n return new Class({\n type: \"nan\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lt(value, params) {\n return new checks.$ZodCheckLessThan({\n check: \"less_than\",\n ...util.normalizeParams(params),\n value,\n inclusive: false,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lte(value, params) {\n return new checks.$ZodCheckLessThan({\n check: \"less_than\",\n ...util.normalizeParams(params),\n value,\n inclusive: true,\n });\n}\nexport { \n/** @deprecated Use `z.lte()` instead. */\n_lte as _max, };\n// @__NO_SIDE_EFFECTS__\nexport function _gt(value, params) {\n return new checks.$ZodCheckGreaterThan({\n check: \"greater_than\",\n ...util.normalizeParams(params),\n value,\n inclusive: false,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _gte(value, params) {\n return new checks.$ZodCheckGreaterThan({\n check: \"greater_than\",\n ...util.normalizeParams(params),\n value,\n inclusive: true,\n });\n}\nexport { \n/** @deprecated Use `z.gte()` instead. */\n_gte as _min, };\n// @__NO_SIDE_EFFECTS__\nexport function _positive(params) {\n return _gt(0, params);\n}\n// negative\n// @__NO_SIDE_EFFECTS__\nexport function _negative(params) {\n return _lt(0, params);\n}\n// nonpositive\n// @__NO_SIDE_EFFECTS__\nexport function _nonpositive(params) {\n return _lte(0, params);\n}\n// nonnegative\n// @__NO_SIDE_EFFECTS__\nexport function _nonnegative(params) {\n return _gte(0, params);\n}\n// @__NO_SIDE_EFFECTS__\nexport function _multipleOf(value, params) {\n return new checks.$ZodCheckMultipleOf({\n check: \"multiple_of\",\n ...util.normalizeParams(params),\n value,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _maxSize(maximum, params) {\n return new checks.$ZodCheckMaxSize({\n check: \"max_size\",\n ...util.normalizeParams(params),\n maximum,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _minSize(minimum, params) {\n return new checks.$ZodCheckMinSize({\n check: \"min_size\",\n ...util.normalizeParams(params),\n minimum,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _size(size, params) {\n return new checks.$ZodCheckSizeEquals({\n check: \"size_equals\",\n ...util.normalizeParams(params),\n size,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _maxLength(maximum, params) {\n const ch = new checks.$ZodCheckMaxLength({\n check: \"max_length\",\n ...util.normalizeParams(params),\n maximum,\n });\n return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _minLength(minimum, params) {\n return new checks.$ZodCheckMinLength({\n check: \"min_length\",\n ...util.normalizeParams(params),\n minimum,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _length(length, params) {\n return new checks.$ZodCheckLengthEquals({\n check: \"length_equals\",\n ...util.normalizeParams(params),\n length,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _regex(pattern, params) {\n return new checks.$ZodCheckRegex({\n check: \"string_format\",\n format: \"regex\",\n ...util.normalizeParams(params),\n pattern,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lowercase(params) {\n return new checks.$ZodCheckLowerCase({\n check: \"string_format\",\n format: \"lowercase\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _uppercase(params) {\n return new checks.$ZodCheckUpperCase({\n check: \"string_format\",\n format: \"uppercase\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _includes(includes, params) {\n return new checks.$ZodCheckIncludes({\n check: \"string_format\",\n format: \"includes\",\n ...util.normalizeParams(params),\n includes,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _startsWith(prefix, params) {\n return new checks.$ZodCheckStartsWith({\n check: \"string_format\",\n format: \"starts_with\",\n ...util.normalizeParams(params),\n prefix,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _endsWith(suffix, params) {\n return new checks.$ZodCheckEndsWith({\n check: \"string_format\",\n format: \"ends_with\",\n ...util.normalizeParams(params),\n suffix,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _property(property, schema, params) {\n return new checks.$ZodCheckProperty({\n check: \"property\",\n property,\n schema,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _mime(types, params) {\n return new checks.$ZodCheckMimeType({\n check: \"mime_type\",\n mime: types,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _overwrite(tx) {\n return new checks.$ZodCheckOverwrite({\n check: \"overwrite\",\n tx,\n });\n}\n// normalize\n// @__NO_SIDE_EFFECTS__\nexport function _normalize(form) {\n return _overwrite((input) => input.normalize(form));\n}\n// trim\n// @__NO_SIDE_EFFECTS__\nexport function _trim() {\n return _overwrite((input) => input.trim());\n}\n// toLowerCase\n// @__NO_SIDE_EFFECTS__\nexport function _toLowerCase() {\n return _overwrite((input) => input.toLowerCase());\n}\n// toUpperCase\n// @__NO_SIDE_EFFECTS__\nexport function _toUpperCase() {\n return _overwrite((input) => input.toUpperCase());\n}\n// slugify\n// @__NO_SIDE_EFFECTS__\nexport function _slugify() {\n return _overwrite((input) => util.slugify(input));\n}\n// @__NO_SIDE_EFFECTS__\nexport function _array(Class, element, params) {\n return new Class({\n type: \"array\",\n element,\n // get element() {\n // return element;\n // },\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _union(Class, options, params) {\n return new Class({\n type: \"union\",\n options,\n ...util.normalizeParams(params),\n });\n}\nexport function _xor(Class, options, params) {\n return new Class({\n type: \"union\",\n options,\n inclusive: false,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _discriminatedUnion(Class, discriminator, options, params) {\n return new Class({\n type: \"union\",\n options,\n discriminator,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _intersection(Class, left, right) {\n return new Class({\n type: \"intersection\",\n left,\n right,\n });\n}\n// export function _tuple(\n// Class: util.SchemaClass,\n// items: [],\n// params?: string | $ZodTupleParams\n// ): schemas.$ZodTuple<[], null>;\n// @__NO_SIDE_EFFECTS__\nexport function _tuple(Class, items, _paramsOrRest, _params) {\n const hasRest = _paramsOrRest instanceof schemas.$ZodType;\n const params = hasRest ? _params : _paramsOrRest;\n const rest = hasRest ? _paramsOrRest : null;\n return new Class({\n type: \"tuple\",\n items,\n rest,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _record(Class, keyType, valueType, params) {\n return new Class({\n type: \"record\",\n keyType,\n valueType,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _map(Class, keyType, valueType, params) {\n return new Class({\n type: \"map\",\n keyType,\n valueType,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _set(Class, valueType, params) {\n return new Class({\n type: \"set\",\n valueType,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _enum(Class, values, params) {\n const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n // if (Array.isArray(values)) {\n // for (const value of values) {\n // entries[value] = value;\n // }\n // } else {\n // Object.assign(entries, values);\n // }\n // const entries: util.EnumLike = {};\n // for (const val of values) {\n // entries[val] = val;\n // }\n return new Class({\n type: \"enum\",\n entries,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport function _nativeEnum(Class, entries, params) {\n return new Class({\n type: \"enum\",\n entries,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _literal(Class, value, params) {\n return new Class({\n type: \"literal\",\n values: Array.isArray(value) ? value : [value],\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _file(Class, params) {\n return new Class({\n type: \"file\",\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _transform(Class, fn) {\n return new Class({\n type: \"transform\",\n transform: fn,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _optional(Class, innerType) {\n return new Class({\n type: \"optional\",\n innerType,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nullable(Class, innerType) {\n return new Class({\n type: \"nullable\",\n innerType,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _default(Class, innerType, defaultValue) {\n return new Class({\n type: \"default\",\n innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n },\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _nonoptional(Class, innerType, params) {\n return new Class({\n type: \"nonoptional\",\n innerType,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _success(Class, innerType) {\n return new Class({\n type: \"success\",\n innerType,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _catch(Class, innerType, catchValue) {\n return new Class({\n type: \"catch\",\n innerType,\n catchValue: (typeof catchValue === \"function\" ? catchValue : () => catchValue),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _pipe(Class, in_, out) {\n return new Class({\n type: \"pipe\",\n in: in_,\n out,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _readonly(Class, innerType) {\n return new Class({\n type: \"readonly\",\n innerType,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _templateLiteral(Class, parts, params) {\n return new Class({\n type: \"template_literal\",\n parts,\n ...util.normalizeParams(params),\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _lazy(Class, getter) {\n return new Class({\n type: \"lazy\",\n getter,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _promise(Class, innerType) {\n return new Class({\n type: \"promise\",\n innerType,\n });\n}\n// @__NO_SIDE_EFFECTS__\nexport function _custom(Class, fn, _params) {\n const norm = util.normalizeParams(_params);\n norm.abort ?? (norm.abort = true); // default to abort:false\n const schema = new Class({\n type: \"custom\",\n check: \"custom\",\n fn: fn,\n ...norm,\n });\n return schema;\n}\n// same as _custom but defaults to abort:false\n// @__NO_SIDE_EFFECTS__\nexport function _refine(Class, fn, _params) {\n const schema = new Class({\n type: \"custom\",\n check: \"custom\",\n fn: fn,\n ...util.normalizeParams(_params),\n });\n return schema;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _superRefine(fn) {\n const ch = _check((payload) => {\n payload.addIssue = (issue) => {\n if (typeof issue === \"string\") {\n payload.issues.push(util.issue(issue, payload.value, ch._zod.def));\n }\n else {\n // for Zod 3 backwards compatibility\n const _issue = issue;\n if (_issue.fatal)\n _issue.continue = false;\n _issue.code ?? (_issue.code = \"custom\");\n _issue.input ?? (_issue.input = payload.value);\n _issue.inst ?? (_issue.inst = ch);\n _issue.continue ?? (_issue.continue = !ch._zod.def.abort); // abort is always undefined, so this is always true...\n payload.issues.push(util.issue(_issue));\n }\n };\n return fn(payload.value, payload);\n });\n return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _check(fn, params) {\n const ch = new checks.$ZodCheck({\n check: \"custom\",\n ...util.normalizeParams(params),\n });\n ch._zod.check = fn;\n return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function describe(description) {\n const ch = new checks.$ZodCheck({ check: \"describe\" });\n ch._zod.onattach = [\n (inst) => {\n const existing = registries.globalRegistry.get(inst) ?? {};\n registries.globalRegistry.add(inst, { ...existing, description });\n },\n ];\n ch._zod.check = () => { }; // no-op check\n return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function meta(metadata) {\n const ch = new checks.$ZodCheck({ check: \"meta\" });\n ch._zod.onattach = [\n (inst) => {\n const existing = registries.globalRegistry.get(inst) ?? {};\n registries.globalRegistry.add(inst, { ...existing, ...metadata });\n },\n ];\n ch._zod.check = () => { }; // no-op check\n return ch;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _stringbool(Classes, _params) {\n const params = util.normalizeParams(_params);\n let truthyArray = params.truthy ?? [\"true\", \"1\", \"yes\", \"on\", \"y\", \"enabled\"];\n let falsyArray = params.falsy ?? [\"false\", \"0\", \"no\", \"off\", \"n\", \"disabled\"];\n if (params.case !== \"sensitive\") {\n truthyArray = truthyArray.map((v) => (typeof v === \"string\" ? v.toLowerCase() : v));\n falsyArray = falsyArray.map((v) => (typeof v === \"string\" ? v.toLowerCase() : v));\n }\n const truthySet = new Set(truthyArray);\n const falsySet = new Set(falsyArray);\n const _Codec = Classes.Codec ?? schemas.$ZodCodec;\n const _Boolean = Classes.Boolean ?? schemas.$ZodBoolean;\n const _String = Classes.String ?? schemas.$ZodString;\n const stringSchema = new _String({ type: \"string\", error: params.error });\n const booleanSchema = new _Boolean({ type: \"boolean\", error: params.error });\n const codec = new _Codec({\n type: \"pipe\",\n in: stringSchema,\n out: booleanSchema,\n transform: ((input, payload) => {\n let data = input;\n if (params.case !== \"sensitive\")\n data = data.toLowerCase();\n if (truthySet.has(data)) {\n return true;\n }\n else if (falsySet.has(data)) {\n return false;\n }\n else {\n payload.issues.push({\n code: \"invalid_value\",\n expected: \"stringbool\",\n values: [...truthySet, ...falsySet],\n input: payload.value,\n inst: codec,\n continue: false,\n });\n return {};\n }\n }),\n reverseTransform: ((input, _payload) => {\n if (input === true) {\n return truthyArray[0] || \"true\";\n }\n else {\n return falsyArray[0] || \"false\";\n }\n }),\n error: params.error,\n });\n return codec;\n}\n// @__NO_SIDE_EFFECTS__\nexport function _stringFormat(Class, format, fnOrRegex, _params = {}) {\n const params = util.normalizeParams(_params);\n const def = {\n ...util.normalizeParams(_params),\n check: \"string_format\",\n type: \"string\",\n format,\n fn: typeof fnOrRegex === \"function\" ? fnOrRegex : (val) => fnOrRegex.test(val),\n ...params,\n };\n if (fnOrRegex instanceof RegExp) {\n def.pattern = fnOrRegex;\n }\n const inst = new Class(def);\n return inst;\n}\n", "import { globalRegistry } from \"./registries.js\";\n// function initializeContext(inputs: JSONSchemaGeneratorParams): ToJSONSchemaContext {\n// return {\n// processor: inputs.processor,\n// metadataRegistry: inputs.metadata ?? globalRegistry,\n// target: inputs.target ?? \"draft-2020-12\",\n// unrepresentable: inputs.unrepresentable ?? \"throw\",\n// };\n// }\nexport function initializeContext(params) {\n // Normalize target: convert old non-hyphenated versions to hyphenated versions\n let target = params?.target ?? \"draft-2020-12\";\n if (target === \"draft-4\")\n target = \"draft-04\";\n if (target === \"draft-7\")\n target = \"draft-07\";\n return {\n processors: params.processors ?? {},\n metadataRegistry: params?.metadata ?? globalRegistry,\n target,\n unrepresentable: params?.unrepresentable ?? \"throw\",\n override: params?.override ?? (() => { }),\n io: params?.io ?? \"output\",\n counter: 0,\n seen: new Map(),\n cycles: params?.cycles ?? \"ref\",\n reused: params?.reused ?? \"inline\",\n external: params?.external ?? undefined,\n };\n}\nexport function process(schema, ctx, _params = { path: [], schemaPath: [] }) {\n var _a;\n const def = schema._zod.def;\n // check for schema in seens\n const seen = ctx.seen.get(schema);\n if (seen) {\n seen.count++;\n // check if cycle\n const isCycle = _params.schemaPath.includes(schema);\n if (isCycle) {\n seen.cycle = _params.path;\n }\n return seen.schema;\n }\n // initialize\n const result = { schema: {}, count: 1, cycle: undefined, path: _params.path };\n ctx.seen.set(schema, result);\n // custom method overrides default behavior\n const overrideSchema = schema._zod.toJSONSchema?.();\n if (overrideSchema) {\n result.schema = overrideSchema;\n }\n else {\n const params = {\n ..._params,\n schemaPath: [..._params.schemaPath, schema],\n path: _params.path,\n };\n if (schema._zod.processJSONSchema) {\n schema._zod.processJSONSchema(ctx, result.schema, params);\n }\n else {\n const _json = result.schema;\n const processor = ctx.processors[def.type];\n if (!processor) {\n throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);\n }\n processor(schema, ctx, _json, params);\n }\n const parent = schema._zod.parent;\n if (parent) {\n // Also set ref if processor didn't (for inheritance)\n if (!result.ref)\n result.ref = parent;\n process(parent, ctx, params);\n ctx.seen.get(parent).isParent = true;\n }\n }\n // metadata\n const meta = ctx.metadataRegistry.get(schema);\n if (meta)\n Object.assign(result.schema, meta);\n if (ctx.io === \"input\" && isTransforming(schema)) {\n // examples/defaults only apply to output type of pipe\n delete result.schema.examples;\n delete result.schema.default;\n }\n // set prefault as default\n if (ctx.io === \"input\" && result.schema._prefault)\n (_a = result.schema).default ?? (_a.default = result.schema._prefault);\n delete result.schema._prefault;\n // pulling fresh from ctx.seen in case it was overwritten\n const _result = ctx.seen.get(schema);\n return _result.schema;\n}\nexport function extractDefs(ctx, schema\n// params: EmitParams\n) {\n // iterate over seen map;\n const root = ctx.seen.get(schema);\n if (!root)\n throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n // Track ids to detect duplicates across different schemas\n const idToSchema = new Map();\n for (const entry of ctx.seen.entries()) {\n const id = ctx.metadataRegistry.get(entry[0])?.id;\n if (id) {\n const existing = idToSchema.get(id);\n if (existing && existing !== entry[0]) {\n throw new Error(`Duplicate schema id \"${id}\" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);\n }\n idToSchema.set(id, entry[0]);\n }\n }\n // returns a ref to the schema\n // defId will be empty if the ref points to an external schema (or #)\n const makeURI = (entry) => {\n // comparing the seen objects because sometimes\n // multiple schemas map to the same seen object.\n // e.g. lazy\n // external is configured\n const defsSegment = ctx.target === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n if (ctx.external) {\n const externalId = ctx.external.registry.get(entry[0])?.id; // ?? \"__shared\";// `__schema${ctx.counter++}`;\n // check if schema is in the external registry\n const uriGenerator = ctx.external.uri ?? ((id) => id);\n if (externalId) {\n return { ref: uriGenerator(externalId) };\n }\n // otherwise, add to __shared\n const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;\n entry[1].defId = id; // set defId so it will be reused if needed\n return { defId: id, ref: `${uriGenerator(\"__shared\")}#/${defsSegment}/${id}` };\n }\n if (entry[1] === root) {\n return { ref: \"#\" };\n }\n // self-contained schema\n const uriPrefix = `#`;\n const defUriPrefix = `${uriPrefix}/${defsSegment}/`;\n const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;\n return { defId, ref: defUriPrefix + defId };\n };\n // stored cached version in `def` property\n // remove all properties, set $ref\n const extractToDef = (entry) => {\n // if the schema is already a reference, do not extract it\n if (entry[1].schema.$ref) {\n return;\n }\n const seen = entry[1];\n const { ref, defId } = makeURI(entry);\n seen.def = { ...seen.schema };\n // defId won't be set if the schema is a reference to an external schema\n // or if the schema is the root schema\n if (defId)\n seen.defId = defId;\n // wipe away all properties except $ref\n const schema = seen.schema;\n for (const key in schema) {\n delete schema[key];\n }\n schema.$ref = ref;\n };\n // throw on cycles\n // break cycles\n if (ctx.cycles === \"throw\") {\n for (const entry of ctx.seen.entries()) {\n const seen = entry[1];\n if (seen.cycle) {\n throw new Error(\"Cycle detected: \" +\n `#/${seen.cycle?.join(\"/\")}/` +\n '\\n\\nSet the `cycles` parameter to `\"ref\"` to resolve cyclical schemas with defs.');\n }\n }\n }\n // extract schemas into $defs\n for (const entry of ctx.seen.entries()) {\n const seen = entry[1];\n // convert root schema to # $ref\n if (schema === entry[0]) {\n extractToDef(entry); // this has special handling for the root schema\n continue;\n }\n // extract schemas that are in the external registry\n if (ctx.external) {\n const ext = ctx.external.registry.get(entry[0])?.id;\n if (schema !== entry[0] && ext) {\n extractToDef(entry);\n continue;\n }\n }\n // extract schemas with `id` meta\n const id = ctx.metadataRegistry.get(entry[0])?.id;\n if (id) {\n extractToDef(entry);\n continue;\n }\n // break cycles\n if (seen.cycle) {\n // any\n extractToDef(entry);\n continue;\n }\n // extract reused schemas\n if (seen.count > 1) {\n if (ctx.reused === \"ref\") {\n extractToDef(entry);\n // biome-ignore lint:\n continue;\n }\n }\n }\n}\nexport function finalize(ctx, schema) {\n const root = ctx.seen.get(schema);\n if (!root)\n throw new Error(\"Unprocessed schema. This is a bug in Zod.\");\n // flatten refs - inherit properties from parent schemas\n const flattenRef = (zodSchema) => {\n const seen = ctx.seen.get(zodSchema);\n // already processed\n if (seen.ref === null)\n return;\n const schema = seen.def ?? seen.schema;\n const _cached = { ...schema };\n const ref = seen.ref;\n seen.ref = null; // prevent infinite recursion\n if (ref) {\n flattenRef(ref);\n const refSeen = ctx.seen.get(ref);\n const refSchema = refSeen.schema;\n // merge referenced schema into current\n if (refSchema.$ref && (ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\")) {\n // older drafts can't combine $ref with other properties\n schema.allOf = schema.allOf ?? [];\n schema.allOf.push(refSchema);\n }\n else {\n Object.assign(schema, refSchema);\n }\n // restore child's own properties (child wins)\n Object.assign(schema, _cached);\n const isParentRef = zodSchema._zod.parent === ref;\n // For parent chain, child is a refinement - remove parent-only properties\n if (isParentRef) {\n for (const key in schema) {\n if (key === \"$ref\" || key === \"allOf\")\n continue;\n if (!(key in _cached)) {\n delete schema[key];\n }\n }\n }\n // When ref was extracted to $defs, remove properties that match the definition\n if (refSchema.$ref && refSeen.def) {\n for (const key in schema) {\n if (key === \"$ref\" || key === \"allOf\")\n continue;\n if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {\n delete schema[key];\n }\n }\n }\n }\n // If parent was extracted (has $ref), propagate $ref to this schema\n // This handles cases like: readonly().meta({id}).describe()\n // where processor sets ref to innerType but parent should be referenced\n const parent = zodSchema._zod.parent;\n if (parent && parent !== ref) {\n // Ensure parent is processed first so its def has inherited properties\n flattenRef(parent);\n const parentSeen = ctx.seen.get(parent);\n if (parentSeen?.schema.$ref) {\n schema.$ref = parentSeen.schema.$ref;\n // De-duplicate with parent's definition\n if (parentSeen.def) {\n for (const key in schema) {\n if (key === \"$ref\" || key === \"allOf\")\n continue;\n if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {\n delete schema[key];\n }\n }\n }\n }\n }\n // execute overrides\n ctx.override({\n zodSchema: zodSchema,\n jsonSchema: schema,\n path: seen.path ?? [],\n });\n };\n for (const entry of [...ctx.seen.entries()].reverse()) {\n flattenRef(entry[0]);\n }\n const result = {};\n if (ctx.target === \"draft-2020-12\") {\n result.$schema = \"https://json-schema.org/draft/2020-12/schema\";\n }\n else if (ctx.target === \"draft-07\") {\n result.$schema = \"http://json-schema.org/draft-07/schema#\";\n }\n else if (ctx.target === \"draft-04\") {\n result.$schema = \"http://json-schema.org/draft-04/schema#\";\n }\n else if (ctx.target === \"openapi-3.0\") {\n // OpenAPI 3.0 schema objects should not include a $schema property\n }\n else {\n // Arbitrary string values are allowed but won't have a $schema property set\n }\n if (ctx.external?.uri) {\n const id = ctx.external.registry.get(schema)?.id;\n if (!id)\n throw new Error(\"Schema is missing an `id` property\");\n result.$id = ctx.external.uri(id);\n }\n Object.assign(result, root.def ?? root.schema);\n // build defs object\n const defs = ctx.external?.defs ?? {};\n for (const entry of ctx.seen.entries()) {\n const seen = entry[1];\n if (seen.def && seen.defId) {\n defs[seen.defId] = seen.def;\n }\n }\n // set definitions in result\n if (ctx.external) {\n }\n else {\n if (Object.keys(defs).length > 0) {\n if (ctx.target === \"draft-2020-12\") {\n result.$defs = defs;\n }\n else {\n result.definitions = defs;\n }\n }\n }\n try {\n // this \"finalizes\" this schema and ensures all cycles are removed\n // each call to finalize() is functionally independent\n // though the seen map is shared\n const finalized = JSON.parse(JSON.stringify(result));\n Object.defineProperty(finalized, \"~standard\", {\n value: {\n ...schema[\"~standard\"],\n jsonSchema: {\n input: createStandardJSONSchemaMethod(schema, \"input\", ctx.processors),\n output: createStandardJSONSchemaMethod(schema, \"output\", ctx.processors),\n },\n },\n enumerable: false,\n writable: false,\n });\n return finalized;\n }\n catch (_err) {\n throw new Error(\"Error converting schema to JSON.\");\n }\n}\nfunction isTransforming(_schema, _ctx) {\n const ctx = _ctx ?? { seen: new Set() };\n if (ctx.seen.has(_schema))\n return false;\n ctx.seen.add(_schema);\n const def = _schema._zod.def;\n if (def.type === \"transform\")\n return true;\n if (def.type === \"array\")\n return isTransforming(def.element, ctx);\n if (def.type === \"set\")\n return isTransforming(def.valueType, ctx);\n if (def.type === \"lazy\")\n return isTransforming(def.getter(), ctx);\n if (def.type === \"promise\" ||\n def.type === \"optional\" ||\n def.type === \"nonoptional\" ||\n def.type === \"nullable\" ||\n def.type === \"readonly\" ||\n def.type === \"default\" ||\n def.type === \"prefault\") {\n return isTransforming(def.innerType, ctx);\n }\n if (def.type === \"intersection\") {\n return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);\n }\n if (def.type === \"record\" || def.type === \"map\") {\n return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);\n }\n if (def.type === \"pipe\") {\n return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);\n }\n if (def.type === \"object\") {\n for (const key in def.shape) {\n if (isTransforming(def.shape[key], ctx))\n return true;\n }\n return false;\n }\n if (def.type === \"union\") {\n for (const option of def.options) {\n if (isTransforming(option, ctx))\n return true;\n }\n return false;\n }\n if (def.type === \"tuple\") {\n for (const item of def.items) {\n if (isTransforming(item, ctx))\n return true;\n }\n if (def.rest && isTransforming(def.rest, ctx))\n return true;\n return false;\n }\n return false;\n}\n/**\n * Creates a toJSONSchema method for a schema instance.\n * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.\n */\nexport const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {\n const ctx = initializeContext({ ...params, processors });\n process(schema, ctx);\n extractDefs(ctx, schema);\n return finalize(ctx, schema);\n};\nexport const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {\n const { libraryOptions, target } = params ?? {};\n const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });\n process(schema, ctx);\n extractDefs(ctx, schema);\n return finalize(ctx, schema);\n};\n", "import { extractDefs, finalize, initializeContext, process, } from \"./to-json-schema.js\";\nimport { getEnumValues } from \"./util.js\";\nconst formatMap = {\n guid: \"uuid\",\n url: \"uri\",\n datetime: \"date-time\",\n json_string: \"json-string\",\n regex: \"\", // do not set\n};\n// ==================== SIMPLE TYPE PROCESSORS ====================\nexport const stringProcessor = (schema, ctx, _json, _params) => {\n const json = _json;\n json.type = \"string\";\n const { minimum, maximum, format, patterns, contentEncoding } = schema._zod\n .bag;\n if (typeof minimum === \"number\")\n json.minLength = minimum;\n if (typeof maximum === \"number\")\n json.maxLength = maximum;\n // custom pattern overrides format\n if (format) {\n json.format = formatMap[format] ?? format;\n if (json.format === \"\")\n delete json.format; // empty format is not valid\n // JSON Schema format: \"time\" requires a full time with offset or Z\n // z.iso.time() does not include timezone information, so format: \"time\" should never be used\n if (format === \"time\") {\n delete json.format;\n }\n }\n if (contentEncoding)\n json.contentEncoding = contentEncoding;\n if (patterns && patterns.size > 0) {\n const regexes = [...patterns];\n if (regexes.length === 1)\n json.pattern = regexes[0].source;\n else if (regexes.length > 1) {\n json.allOf = [\n ...regexes.map((regex) => ({\n ...(ctx.target === \"draft-07\" || ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\"\n ? { type: \"string\" }\n : {}),\n pattern: regex.source,\n })),\n ];\n }\n }\n};\nexport const numberProcessor = (schema, ctx, _json, _params) => {\n const json = _json;\n const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;\n if (typeof format === \"string\" && format.includes(\"int\"))\n json.type = \"integer\";\n else\n json.type = \"number\";\n if (typeof exclusiveMinimum === \"number\") {\n if (ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\") {\n json.minimum = exclusiveMinimum;\n json.exclusiveMinimum = true;\n }\n else {\n json.exclusiveMinimum = exclusiveMinimum;\n }\n }\n if (typeof minimum === \"number\") {\n json.minimum = minimum;\n if (typeof exclusiveMinimum === \"number\" && ctx.target !== \"draft-04\") {\n if (exclusiveMinimum >= minimum)\n delete json.minimum;\n else\n delete json.exclusiveMinimum;\n }\n }\n if (typeof exclusiveMaximum === \"number\") {\n if (ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\") {\n json.maximum = exclusiveMaximum;\n json.exclusiveMaximum = true;\n }\n else {\n json.exclusiveMaximum = exclusiveMaximum;\n }\n }\n if (typeof maximum === \"number\") {\n json.maximum = maximum;\n if (typeof exclusiveMaximum === \"number\" && ctx.target !== \"draft-04\") {\n if (exclusiveMaximum <= maximum)\n delete json.maximum;\n else\n delete json.exclusiveMaximum;\n }\n }\n if (typeof multipleOf === \"number\")\n json.multipleOf = multipleOf;\n};\nexport const booleanProcessor = (_schema, _ctx, json, _params) => {\n json.type = \"boolean\";\n};\nexport const bigintProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"BigInt cannot be represented in JSON Schema\");\n }\n};\nexport const symbolProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Symbols cannot be represented in JSON Schema\");\n }\n};\nexport const nullProcessor = (_schema, ctx, json, _params) => {\n if (ctx.target === \"openapi-3.0\") {\n json.type = \"string\";\n json.nullable = true;\n json.enum = [null];\n }\n else {\n json.type = \"null\";\n }\n};\nexport const undefinedProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Undefined cannot be represented in JSON Schema\");\n }\n};\nexport const voidProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Void cannot be represented in JSON Schema\");\n }\n};\nexport const neverProcessor = (_schema, _ctx, json, _params) => {\n json.not = {};\n};\nexport const anyProcessor = (_schema, _ctx, _json, _params) => {\n // empty schema accepts anything\n};\nexport const unknownProcessor = (_schema, _ctx, _json, _params) => {\n // empty schema accepts anything\n};\nexport const dateProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Date cannot be represented in JSON Schema\");\n }\n};\nexport const enumProcessor = (schema, _ctx, json, _params) => {\n const def = schema._zod.def;\n const values = getEnumValues(def.entries);\n // Number enums can have both string and number values\n if (values.every((v) => typeof v === \"number\"))\n json.type = \"number\";\n if (values.every((v) => typeof v === \"string\"))\n json.type = \"string\";\n json.enum = values;\n};\nexport const literalProcessor = (schema, ctx, json, _params) => {\n const def = schema._zod.def;\n const vals = [];\n for (const val of def.values) {\n if (val === undefined) {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Literal `undefined` cannot be represented in JSON Schema\");\n }\n else {\n // do not add to vals\n }\n }\n else if (typeof val === \"bigint\") {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"BigInt literals cannot be represented in JSON Schema\");\n }\n else {\n vals.push(Number(val));\n }\n }\n else {\n vals.push(val);\n }\n }\n if (vals.length === 0) {\n // do nothing (an undefined literal was stripped)\n }\n else if (vals.length === 1) {\n const val = vals[0];\n json.type = val === null ? \"null\" : typeof val;\n if (ctx.target === \"draft-04\" || ctx.target === \"openapi-3.0\") {\n json.enum = [val];\n }\n else {\n json.const = val;\n }\n }\n else {\n if (vals.every((v) => typeof v === \"number\"))\n json.type = \"number\";\n if (vals.every((v) => typeof v === \"string\"))\n json.type = \"string\";\n if (vals.every((v) => typeof v === \"boolean\"))\n json.type = \"boolean\";\n if (vals.every((v) => v === null))\n json.type = \"null\";\n json.enum = vals;\n }\n};\nexport const nanProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"NaN cannot be represented in JSON Schema\");\n }\n};\nexport const templateLiteralProcessor = (schema, _ctx, json, _params) => {\n const _json = json;\n const pattern = schema._zod.pattern;\n if (!pattern)\n throw new Error(\"Pattern not found in template literal\");\n _json.type = \"string\";\n _json.pattern = pattern.source;\n};\nexport const fileProcessor = (schema, _ctx, json, _params) => {\n const _json = json;\n const file = {\n type: \"string\",\n format: \"binary\",\n contentEncoding: \"binary\",\n };\n const { minimum, maximum, mime } = schema._zod.bag;\n if (minimum !== undefined)\n file.minLength = minimum;\n if (maximum !== undefined)\n file.maxLength = maximum;\n if (mime) {\n if (mime.length === 1) {\n file.contentMediaType = mime[0];\n Object.assign(_json, file);\n }\n else {\n Object.assign(_json, file); // shared props at root\n _json.anyOf = mime.map((m) => ({ contentMediaType: m })); // only contentMediaType differs\n }\n }\n else {\n Object.assign(_json, file);\n }\n};\nexport const successProcessor = (_schema, _ctx, json, _params) => {\n json.type = \"boolean\";\n};\nexport const customProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Custom types cannot be represented in JSON Schema\");\n }\n};\nexport const functionProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Function types cannot be represented in JSON Schema\");\n }\n};\nexport const transformProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Transforms cannot be represented in JSON Schema\");\n }\n};\nexport const mapProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Map cannot be represented in JSON Schema\");\n }\n};\nexport const setProcessor = (_schema, ctx, _json, _params) => {\n if (ctx.unrepresentable === \"throw\") {\n throw new Error(\"Set cannot be represented in JSON Schema\");\n }\n};\n// ==================== COMPOSITE TYPE PROCESSORS ====================\nexport const arrayProcessor = (schema, ctx, _json, params) => {\n const json = _json;\n const def = schema._zod.def;\n const { minimum, maximum } = schema._zod.bag;\n if (typeof minimum === \"number\")\n json.minItems = minimum;\n if (typeof maximum === \"number\")\n json.maxItems = maximum;\n json.type = \"array\";\n json.items = process(def.element, ctx, { ...params, path: [...params.path, \"items\"] });\n};\nexport const objectProcessor = (schema, ctx, _json, params) => {\n const json = _json;\n const def = schema._zod.def;\n json.type = \"object\";\n json.properties = {};\n const shape = def.shape;\n for (const key in shape) {\n json.properties[key] = process(shape[key], ctx, {\n ...params,\n path: [...params.path, \"properties\", key],\n });\n }\n // required keys\n const allKeys = new Set(Object.keys(shape));\n const requiredKeys = new Set([...allKeys].filter((key) => {\n const v = def.shape[key]._zod;\n if (ctx.io === \"input\") {\n return v.optin === undefined;\n }\n else {\n return v.optout === undefined;\n }\n }));\n if (requiredKeys.size > 0) {\n json.required = Array.from(requiredKeys);\n }\n // catchall\n if (def.catchall?._zod.def.type === \"never\") {\n // strict\n json.additionalProperties = false;\n }\n else if (!def.catchall) {\n // regular\n if (ctx.io === \"output\")\n json.additionalProperties = false;\n }\n else if (def.catchall) {\n json.additionalProperties = process(def.catchall, ctx, {\n ...params,\n path: [...params.path, \"additionalProperties\"],\n });\n }\n};\nexport const unionProcessor = (schema, ctx, json, params) => {\n const def = schema._zod.def;\n // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)\n // This includes both z.xor() and discriminated unions\n const isExclusive = def.inclusive === false;\n const options = def.options.map((x, i) => process(x, ctx, {\n ...params,\n path: [...params.path, isExclusive ? \"oneOf\" : \"anyOf\", i],\n }));\n if (isExclusive) {\n json.oneOf = options;\n }\n else {\n json.anyOf = options;\n }\n};\nexport const intersectionProcessor = (schema, ctx, json, params) => {\n const def = schema._zod.def;\n const a = process(def.left, ctx, {\n ...params,\n path: [...params.path, \"allOf\", 0],\n });\n const b = process(def.right, ctx, {\n ...params,\n path: [...params.path, \"allOf\", 1],\n });\n const isSimpleIntersection = (val) => \"allOf\" in val && Object.keys(val).length === 1;\n const allOf = [\n ...(isSimpleIntersection(a) ? a.allOf : [a]),\n ...(isSimpleIntersection(b) ? b.allOf : [b]),\n ];\n json.allOf = allOf;\n};\nexport const tupleProcessor = (schema, ctx, _json, params) => {\n const json = _json;\n const def = schema._zod.def;\n json.type = \"array\";\n const prefixPath = ctx.target === \"draft-2020-12\" ? \"prefixItems\" : \"items\";\n const restPath = ctx.target === \"draft-2020-12\" ? \"items\" : ctx.target === \"openapi-3.0\" ? \"items\" : \"additionalItems\";\n const prefixItems = def.items.map((x, i) => process(x, ctx, {\n ...params,\n path: [...params.path, prefixPath, i],\n }));\n const rest = def.rest\n ? process(def.rest, ctx, {\n ...params,\n path: [...params.path, restPath, ...(ctx.target === \"openapi-3.0\" ? [def.items.length] : [])],\n })\n : null;\n if (ctx.target === \"draft-2020-12\") {\n json.prefixItems = prefixItems;\n if (rest) {\n json.items = rest;\n }\n }\n else if (ctx.target === \"openapi-3.0\") {\n json.items = {\n anyOf: prefixItems,\n };\n if (rest) {\n json.items.anyOf.push(rest);\n }\n json.minItems = prefixItems.length;\n if (!rest) {\n json.maxItems = prefixItems.length;\n }\n }\n else {\n json.items = prefixItems;\n if (rest) {\n json.additionalItems = rest;\n }\n }\n // length\n const { minimum, maximum } = schema._zod.bag;\n if (typeof minimum === \"number\")\n json.minItems = minimum;\n if (typeof maximum === \"number\")\n json.maxItems = maximum;\n};\nexport const recordProcessor = (schema, ctx, _json, params) => {\n const json = _json;\n const def = schema._zod.def;\n json.type = \"object\";\n // For looseRecord with regex patterns, use patternProperties\n // This correctly represents \"only validate keys matching the pattern\" semantics\n // and composes well with allOf (intersections)\n const keyType = def.keyType;\n const keyBag = keyType._zod.bag;\n const patterns = keyBag?.patterns;\n if (def.mode === \"loose\" && patterns && patterns.size > 0) {\n // Use patternProperties for looseRecord with regex patterns\n const valueSchema = process(def.valueType, ctx, {\n ...params,\n path: [...params.path, \"patternProperties\", \"*\"],\n });\n json.patternProperties = {};\n for (const pattern of patterns) {\n json.patternProperties[pattern.source] = valueSchema;\n }\n }\n else {\n // Default behavior: use propertyNames + additionalProperties\n if (ctx.target === \"draft-07\" || ctx.target === \"draft-2020-12\") {\n json.propertyNames = process(def.keyType, ctx, {\n ...params,\n path: [...params.path, \"propertyNames\"],\n });\n }\n json.additionalProperties = process(def.valueType, ctx, {\n ...params,\n path: [...params.path, \"additionalProperties\"],\n });\n }\n // Add required for keys with discrete values (enum, literal, etc.)\n const keyValues = keyType._zod.values;\n if (keyValues) {\n const validKeyValues = [...keyValues].filter((v) => typeof v === \"string\" || typeof v === \"number\");\n if (validKeyValues.length > 0) {\n json.required = validKeyValues;\n }\n }\n};\nexport const nullableProcessor = (schema, ctx, json, params) => {\n const def = schema._zod.def;\n const inner = process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n if (ctx.target === \"openapi-3.0\") {\n seen.ref = def.innerType;\n json.nullable = true;\n }\n else {\n json.anyOf = [inner, { type: \"null\" }];\n }\n};\nexport const nonoptionalProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n};\nexport const defaultProcessor = (schema, ctx, json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n json.default = JSON.parse(JSON.stringify(def.defaultValue));\n};\nexport const prefaultProcessor = (schema, ctx, json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n if (ctx.io === \"input\")\n json._prefault = JSON.parse(JSON.stringify(def.defaultValue));\n};\nexport const catchProcessor = (schema, ctx, json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n let catchValue;\n try {\n catchValue = def.catchValue(undefined);\n }\n catch {\n throw new Error(\"Dynamic catch values are not supported in JSON Schema\");\n }\n json.default = catchValue;\n};\nexport const pipeProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n const innerType = ctx.io === \"input\" ? (def.in._zod.def.type === \"transform\" ? def.out : def.in) : def.out;\n process(innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = innerType;\n};\nexport const readonlyProcessor = (schema, ctx, json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n json.readOnly = true;\n};\nexport const promiseProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n};\nexport const optionalProcessor = (schema, ctx, _json, params) => {\n const def = schema._zod.def;\n process(def.innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = def.innerType;\n};\nexport const lazyProcessor = (schema, ctx, _json, params) => {\n const innerType = schema._zod.innerType;\n process(innerType, ctx, params);\n const seen = ctx.seen.get(schema);\n seen.ref = innerType;\n};\n// ==================== ALL PROCESSORS ====================\nexport const allProcessors = {\n string: stringProcessor,\n number: numberProcessor,\n boolean: booleanProcessor,\n bigint: bigintProcessor,\n symbol: symbolProcessor,\n null: nullProcessor,\n undefined: undefinedProcessor,\n void: voidProcessor,\n never: neverProcessor,\n any: anyProcessor,\n unknown: unknownProcessor,\n date: dateProcessor,\n enum: enumProcessor,\n literal: literalProcessor,\n nan: nanProcessor,\n template_literal: templateLiteralProcessor,\n file: fileProcessor,\n success: successProcessor,\n custom: customProcessor,\n function: functionProcessor,\n transform: transformProcessor,\n map: mapProcessor,\n set: setProcessor,\n array: arrayProcessor,\n object: objectProcessor,\n union: unionProcessor,\n intersection: intersectionProcessor,\n tuple: tupleProcessor,\n record: recordProcessor,\n nullable: nullableProcessor,\n nonoptional: nonoptionalProcessor,\n default: defaultProcessor,\n prefault: prefaultProcessor,\n catch: catchProcessor,\n pipe: pipeProcessor,\n readonly: readonlyProcessor,\n promise: promiseProcessor,\n optional: optionalProcessor,\n lazy: lazyProcessor,\n};\nexport function toJSONSchema(input, params) {\n if (\"_idmap\" in input) {\n // Registry case\n const registry = input;\n const ctx = initializeContext({ ...params, processors: allProcessors });\n const defs = {};\n // First pass: process all schemas to build the seen map\n for (const entry of registry._idmap.entries()) {\n const [_, schema] = entry;\n process(schema, ctx);\n }\n const schemas = {};\n const external = {\n registry,\n uri: params?.uri,\n defs,\n };\n // Update the context with external configuration\n ctx.external = external;\n // Second pass: emit each schema\n for (const entry of registry._idmap.entries()) {\n const [key, schema] = entry;\n extractDefs(ctx, schema);\n schemas[key] = finalize(ctx, schema);\n }\n if (Object.keys(defs).length > 0) {\n const defsSegment = ctx.target === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n schemas.__shared = {\n [defsSegment]: defs,\n };\n }\n return { schemas };\n }\n // Single schema case\n const ctx = initializeContext({ ...params, processors: allProcessors });\n process(input, ctx);\n extractDefs(ctx, input);\n return finalize(ctx, input);\n}\n", null, "import * as core from \"../core/index.js\";\nimport { util } from \"../core/index.js\";\nimport * as processors from \"../core/json-schema-processors.js\";\nimport { createStandardJSONSchemaMethod, createToJSONSchemaMethod } from \"../core/to-json-schema.js\";\nimport * as checks from \"./checks.js\";\nimport * as iso from \"./iso.js\";\nimport * as parse from \"./parse.js\";\nexport const ZodType = /*@__PURE__*/ core.$constructor(\"ZodType\", (inst, def) => {\n core.$ZodType.init(inst, def);\n Object.assign(inst[\"~standard\"], {\n jsonSchema: {\n input: createStandardJSONSchemaMethod(inst, \"input\"),\n output: createStandardJSONSchemaMethod(inst, \"output\"),\n },\n });\n inst.toJSONSchema = createToJSONSchemaMethod(inst, {});\n inst.def = def;\n inst.type = def.type;\n Object.defineProperty(inst, \"_def\", { value: def });\n // base methods\n inst.check = (...checks) => {\n return inst.clone(util.mergeDefs(def, {\n checks: [\n ...(def.checks ?? []),\n ...checks.map((ch) => typeof ch === \"function\" ? { _zod: { check: ch, def: { check: \"custom\" }, onattach: [] } } : ch),\n ],\n }), {\n parent: true,\n });\n };\n inst.with = inst.check;\n inst.clone = (def, params) => core.clone(inst, def, params);\n inst.brand = () => inst;\n inst.register = ((reg, meta) => {\n reg.add(inst, meta);\n return inst;\n });\n // parsing\n inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });\n inst.safeParse = (data, params) => parse.safeParse(inst, data, params);\n inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });\n inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);\n inst.spa = inst.safeParseAsync;\n // encoding/decoding\n inst.encode = (data, params) => parse.encode(inst, data, params);\n inst.decode = (data, params) => parse.decode(inst, data, params);\n inst.encodeAsync = async (data, params) => parse.encodeAsync(inst, data, params);\n inst.decodeAsync = async (data, params) => parse.decodeAsync(inst, data, params);\n inst.safeEncode = (data, params) => parse.safeEncode(inst, data, params);\n inst.safeDecode = (data, params) => parse.safeDecode(inst, data, params);\n inst.safeEncodeAsync = async (data, params) => parse.safeEncodeAsync(inst, data, params);\n inst.safeDecodeAsync = async (data, params) => parse.safeDecodeAsync(inst, data, params);\n // refinements\n inst.refine = (check, params) => inst.check(refine(check, params));\n inst.superRefine = (refinement) => inst.check(superRefine(refinement));\n inst.overwrite = (fn) => inst.check(checks.overwrite(fn));\n // wrappers\n inst.optional = () => optional(inst);\n inst.exactOptional = () => exactOptional(inst);\n inst.nullable = () => nullable(inst);\n inst.nullish = () => optional(nullable(inst));\n inst.nonoptional = (params) => nonoptional(inst, params);\n inst.array = () => array(inst);\n inst.or = (arg) => union([inst, arg]);\n inst.and = (arg) => intersection(inst, arg);\n inst.transform = (tx) => pipe(inst, transform(tx));\n inst.default = (def) => _default(inst, def);\n inst.prefault = (def) => prefault(inst, def);\n // inst.coalesce = (def, params) => coalesce(inst, def, params);\n inst.catch = (params) => _catch(inst, params);\n inst.pipe = (target) => pipe(inst, target);\n inst.readonly = () => readonly(inst);\n // meta\n inst.describe = (description) => {\n const cl = inst.clone();\n core.globalRegistry.add(cl, { description });\n return cl;\n };\n Object.defineProperty(inst, \"description\", {\n get() {\n return core.globalRegistry.get(inst)?.description;\n },\n configurable: true,\n });\n inst.meta = (...args) => {\n if (args.length === 0) {\n return core.globalRegistry.get(inst);\n }\n const cl = inst.clone();\n core.globalRegistry.add(cl, args[0]);\n return cl;\n };\n // helpers\n inst.isOptional = () => inst.safeParse(undefined).success;\n inst.isNullable = () => inst.safeParse(null).success;\n inst.apply = (fn) => fn(inst);\n return inst;\n});\n/** @internal */\nexport const _ZodString = /*@__PURE__*/ core.$constructor(\"_ZodString\", (inst, def) => {\n core.$ZodString.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.stringProcessor(inst, ctx, json, params);\n const bag = inst._zod.bag;\n inst.format = bag.format ?? null;\n inst.minLength = bag.minimum ?? null;\n inst.maxLength = bag.maximum ?? null;\n // validations\n inst.regex = (...args) => inst.check(checks.regex(...args));\n inst.includes = (...args) => inst.check(checks.includes(...args));\n inst.startsWith = (...args) => inst.check(checks.startsWith(...args));\n inst.endsWith = (...args) => inst.check(checks.endsWith(...args));\n inst.min = (...args) => inst.check(checks.minLength(...args));\n inst.max = (...args) => inst.check(checks.maxLength(...args));\n inst.length = (...args) => inst.check(checks.length(...args));\n inst.nonempty = (...args) => inst.check(checks.minLength(1, ...args));\n inst.lowercase = (params) => inst.check(checks.lowercase(params));\n inst.uppercase = (params) => inst.check(checks.uppercase(params));\n // transforms\n inst.trim = () => inst.check(checks.trim());\n inst.normalize = (...args) => inst.check(checks.normalize(...args));\n inst.toLowerCase = () => inst.check(checks.toLowerCase());\n inst.toUpperCase = () => inst.check(checks.toUpperCase());\n inst.slugify = () => inst.check(checks.slugify());\n});\nexport const ZodString = /*@__PURE__*/ core.$constructor(\"ZodString\", (inst, def) => {\n core.$ZodString.init(inst, def);\n _ZodString.init(inst, def);\n inst.email = (params) => inst.check(core._email(ZodEmail, params));\n inst.url = (params) => inst.check(core._url(ZodURL, params));\n inst.jwt = (params) => inst.check(core._jwt(ZodJWT, params));\n inst.emoji = (params) => inst.check(core._emoji(ZodEmoji, params));\n inst.guid = (params) => inst.check(core._guid(ZodGUID, params));\n inst.uuid = (params) => inst.check(core._uuid(ZodUUID, params));\n inst.uuidv4 = (params) => inst.check(core._uuidv4(ZodUUID, params));\n inst.uuidv6 = (params) => inst.check(core._uuidv6(ZodUUID, params));\n inst.uuidv7 = (params) => inst.check(core._uuidv7(ZodUUID, params));\n inst.nanoid = (params) => inst.check(core._nanoid(ZodNanoID, params));\n inst.guid = (params) => inst.check(core._guid(ZodGUID, params));\n inst.cuid = (params) => inst.check(core._cuid(ZodCUID, params));\n inst.cuid2 = (params) => inst.check(core._cuid2(ZodCUID2, params));\n inst.ulid = (params) => inst.check(core._ulid(ZodULID, params));\n inst.base64 = (params) => inst.check(core._base64(ZodBase64, params));\n inst.base64url = (params) => inst.check(core._base64url(ZodBase64URL, params));\n inst.xid = (params) => inst.check(core._xid(ZodXID, params));\n inst.ksuid = (params) => inst.check(core._ksuid(ZodKSUID, params));\n inst.ipv4 = (params) => inst.check(core._ipv4(ZodIPv4, params));\n inst.ipv6 = (params) => inst.check(core._ipv6(ZodIPv6, params));\n inst.cidrv4 = (params) => inst.check(core._cidrv4(ZodCIDRv4, params));\n inst.cidrv6 = (params) => inst.check(core._cidrv6(ZodCIDRv6, params));\n inst.e164 = (params) => inst.check(core._e164(ZodE164, params));\n // iso\n inst.datetime = (params) => inst.check(iso.datetime(params));\n inst.date = (params) => inst.check(iso.date(params));\n inst.time = (params) => inst.check(iso.time(params));\n inst.duration = (params) => inst.check(iso.duration(params));\n});\nexport function string(params) {\n return core._string(ZodString, params);\n}\nexport const ZodStringFormat = /*@__PURE__*/ core.$constructor(\"ZodStringFormat\", (inst, def) => {\n core.$ZodStringFormat.init(inst, def);\n _ZodString.init(inst, def);\n});\nexport const ZodEmail = /*@__PURE__*/ core.$constructor(\"ZodEmail\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodEmail.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function email(params) {\n return core._email(ZodEmail, params);\n}\nexport const ZodGUID = /*@__PURE__*/ core.$constructor(\"ZodGUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodGUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function guid(params) {\n return core._guid(ZodGUID, params);\n}\nexport const ZodUUID = /*@__PURE__*/ core.$constructor(\"ZodUUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodUUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function uuid(params) {\n return core._uuid(ZodUUID, params);\n}\nexport function uuidv4(params) {\n return core._uuidv4(ZodUUID, params);\n}\n// ZodUUIDv6\nexport function uuidv6(params) {\n return core._uuidv6(ZodUUID, params);\n}\n// ZodUUIDv7\nexport function uuidv7(params) {\n return core._uuidv7(ZodUUID, params);\n}\nexport const ZodURL = /*@__PURE__*/ core.$constructor(\"ZodURL\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodURL.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function url(params) {\n return core._url(ZodURL, params);\n}\nexport function httpUrl(params) {\n return core._url(ZodURL, {\n protocol: /^https?$/,\n hostname: core.regexes.domain,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodEmoji = /*@__PURE__*/ core.$constructor(\"ZodEmoji\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodEmoji.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function emoji(params) {\n return core._emoji(ZodEmoji, params);\n}\nexport const ZodNanoID = /*@__PURE__*/ core.$constructor(\"ZodNanoID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodNanoID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function nanoid(params) {\n return core._nanoid(ZodNanoID, params);\n}\nexport const ZodCUID = /*@__PURE__*/ core.$constructor(\"ZodCUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodCUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function cuid(params) {\n return core._cuid(ZodCUID, params);\n}\nexport const ZodCUID2 = /*@__PURE__*/ core.$constructor(\"ZodCUID2\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodCUID2.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function cuid2(params) {\n return core._cuid2(ZodCUID2, params);\n}\nexport const ZodULID = /*@__PURE__*/ core.$constructor(\"ZodULID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodULID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ulid(params) {\n return core._ulid(ZodULID, params);\n}\nexport const ZodXID = /*@__PURE__*/ core.$constructor(\"ZodXID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodXID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function xid(params) {\n return core._xid(ZodXID, params);\n}\nexport const ZodKSUID = /*@__PURE__*/ core.$constructor(\"ZodKSUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodKSUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ksuid(params) {\n return core._ksuid(ZodKSUID, params);\n}\nexport const ZodIPv4 = /*@__PURE__*/ core.$constructor(\"ZodIPv4\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodIPv4.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ipv4(params) {\n return core._ipv4(ZodIPv4, params);\n}\nexport const ZodMAC = /*@__PURE__*/ core.$constructor(\"ZodMAC\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodMAC.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function mac(params) {\n return core._mac(ZodMAC, params);\n}\nexport const ZodIPv6 = /*@__PURE__*/ core.$constructor(\"ZodIPv6\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodIPv6.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ipv6(params) {\n return core._ipv6(ZodIPv6, params);\n}\nexport const ZodCIDRv4 = /*@__PURE__*/ core.$constructor(\"ZodCIDRv4\", (inst, def) => {\n core.$ZodCIDRv4.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function cidrv4(params) {\n return core._cidrv4(ZodCIDRv4, params);\n}\nexport const ZodCIDRv6 = /*@__PURE__*/ core.$constructor(\"ZodCIDRv6\", (inst, def) => {\n core.$ZodCIDRv6.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function cidrv6(params) {\n return core._cidrv6(ZodCIDRv6, params);\n}\nexport const ZodBase64 = /*@__PURE__*/ core.$constructor(\"ZodBase64\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodBase64.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function base64(params) {\n return core._base64(ZodBase64, params);\n}\nexport const ZodBase64URL = /*@__PURE__*/ core.$constructor(\"ZodBase64URL\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodBase64URL.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function base64url(params) {\n return core._base64url(ZodBase64URL, params);\n}\nexport const ZodE164 = /*@__PURE__*/ core.$constructor(\"ZodE164\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodE164.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function e164(params) {\n return core._e164(ZodE164, params);\n}\nexport const ZodJWT = /*@__PURE__*/ core.$constructor(\"ZodJWT\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodJWT.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function jwt(params) {\n return core._jwt(ZodJWT, params);\n}\nexport const ZodCustomStringFormat = /*@__PURE__*/ core.$constructor(\"ZodCustomStringFormat\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodCustomStringFormat.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function stringFormat(format, fnOrRegex, _params = {}) {\n return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);\n}\nexport function hostname(_params) {\n return core._stringFormat(ZodCustomStringFormat, \"hostname\", core.regexes.hostname, _params);\n}\nexport function hex(_params) {\n return core._stringFormat(ZodCustomStringFormat, \"hex\", core.regexes.hex, _params);\n}\nexport function hash(alg, params) {\n const enc = params?.enc ?? \"hex\";\n const format = `${alg}_${enc}`;\n const regex = core.regexes[format];\n if (!regex)\n throw new Error(`Unrecognized hash format: ${format}`);\n return core._stringFormat(ZodCustomStringFormat, format, regex, params);\n}\nexport const ZodNumber = /*@__PURE__*/ core.$constructor(\"ZodNumber\", (inst, def) => {\n core.$ZodNumber.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.numberProcessor(inst, ctx, json, params);\n inst.gt = (value, params) => inst.check(checks.gt(value, params));\n inst.gte = (value, params) => inst.check(checks.gte(value, params));\n inst.min = (value, params) => inst.check(checks.gte(value, params));\n inst.lt = (value, params) => inst.check(checks.lt(value, params));\n inst.lte = (value, params) => inst.check(checks.lte(value, params));\n inst.max = (value, params) => inst.check(checks.lte(value, params));\n inst.int = (params) => inst.check(int(params));\n inst.safe = (params) => inst.check(int(params));\n inst.positive = (params) => inst.check(checks.gt(0, params));\n inst.nonnegative = (params) => inst.check(checks.gte(0, params));\n inst.negative = (params) => inst.check(checks.lt(0, params));\n inst.nonpositive = (params) => inst.check(checks.lte(0, params));\n inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params));\n inst.step = (value, params) => inst.check(checks.multipleOf(value, params));\n // inst.finite = (params) => inst.check(core.finite(params));\n inst.finite = () => inst;\n const bag = inst._zod.bag;\n inst.minValue =\n Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;\n inst.maxValue =\n Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;\n inst.isInt = (bag.format ?? \"\").includes(\"int\") || Number.isSafeInteger(bag.multipleOf ?? 0.5);\n inst.isFinite = true;\n inst.format = bag.format ?? null;\n});\nexport function number(params) {\n return core._number(ZodNumber, params);\n}\nexport const ZodNumberFormat = /*@__PURE__*/ core.$constructor(\"ZodNumberFormat\", (inst, def) => {\n core.$ZodNumberFormat.init(inst, def);\n ZodNumber.init(inst, def);\n});\nexport function int(params) {\n return core._int(ZodNumberFormat, params);\n}\nexport function float32(params) {\n return core._float32(ZodNumberFormat, params);\n}\nexport function float64(params) {\n return core._float64(ZodNumberFormat, params);\n}\nexport function int32(params) {\n return core._int32(ZodNumberFormat, params);\n}\nexport function uint32(params) {\n return core._uint32(ZodNumberFormat, params);\n}\nexport const ZodBoolean = /*@__PURE__*/ core.$constructor(\"ZodBoolean\", (inst, def) => {\n core.$ZodBoolean.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.booleanProcessor(inst, ctx, json, params);\n});\nexport function boolean(params) {\n return core._boolean(ZodBoolean, params);\n}\nexport const ZodBigInt = /*@__PURE__*/ core.$constructor(\"ZodBigInt\", (inst, def) => {\n core.$ZodBigInt.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.bigintProcessor(inst, ctx, json, params);\n inst.gte = (value, params) => inst.check(checks.gte(value, params));\n inst.min = (value, params) => inst.check(checks.gte(value, params));\n inst.gt = (value, params) => inst.check(checks.gt(value, params));\n inst.gte = (value, params) => inst.check(checks.gte(value, params));\n inst.min = (value, params) => inst.check(checks.gte(value, params));\n inst.lt = (value, params) => inst.check(checks.lt(value, params));\n inst.lte = (value, params) => inst.check(checks.lte(value, params));\n inst.max = (value, params) => inst.check(checks.lte(value, params));\n inst.positive = (params) => inst.check(checks.gt(BigInt(0), params));\n inst.negative = (params) => inst.check(checks.lt(BigInt(0), params));\n inst.nonpositive = (params) => inst.check(checks.lte(BigInt(0), params));\n inst.nonnegative = (params) => inst.check(checks.gte(BigInt(0), params));\n inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params));\n const bag = inst._zod.bag;\n inst.minValue = bag.minimum ?? null;\n inst.maxValue = bag.maximum ?? null;\n inst.format = bag.format ?? null;\n});\nexport function bigint(params) {\n return core._bigint(ZodBigInt, params);\n}\nexport const ZodBigIntFormat = /*@__PURE__*/ core.$constructor(\"ZodBigIntFormat\", (inst, def) => {\n core.$ZodBigIntFormat.init(inst, def);\n ZodBigInt.init(inst, def);\n});\n// int64\nexport function int64(params) {\n return core._int64(ZodBigIntFormat, params);\n}\n// uint64\nexport function uint64(params) {\n return core._uint64(ZodBigIntFormat, params);\n}\nexport const ZodSymbol = /*@__PURE__*/ core.$constructor(\"ZodSymbol\", (inst, def) => {\n core.$ZodSymbol.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.symbolProcessor(inst, ctx, json, params);\n});\nexport function symbol(params) {\n return core._symbol(ZodSymbol, params);\n}\nexport const ZodUndefined = /*@__PURE__*/ core.$constructor(\"ZodUndefined\", (inst, def) => {\n core.$ZodUndefined.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.undefinedProcessor(inst, ctx, json, params);\n});\nfunction _undefined(params) {\n return core._undefined(ZodUndefined, params);\n}\nexport { _undefined as undefined };\nexport const ZodNull = /*@__PURE__*/ core.$constructor(\"ZodNull\", (inst, def) => {\n core.$ZodNull.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nullProcessor(inst, ctx, json, params);\n});\nfunction _null(params) {\n return core._null(ZodNull, params);\n}\nexport { _null as null };\nexport const ZodAny = /*@__PURE__*/ core.$constructor(\"ZodAny\", (inst, def) => {\n core.$ZodAny.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.anyProcessor(inst, ctx, json, params);\n});\nexport function any() {\n return core._any(ZodAny);\n}\nexport const ZodUnknown = /*@__PURE__*/ core.$constructor(\"ZodUnknown\", (inst, def) => {\n core.$ZodUnknown.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.unknownProcessor(inst, ctx, json, params);\n});\nexport function unknown() {\n return core._unknown(ZodUnknown);\n}\nexport const ZodNever = /*@__PURE__*/ core.$constructor(\"ZodNever\", (inst, def) => {\n core.$ZodNever.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.neverProcessor(inst, ctx, json, params);\n});\nexport function never(params) {\n return core._never(ZodNever, params);\n}\nexport const ZodVoid = /*@__PURE__*/ core.$constructor(\"ZodVoid\", (inst, def) => {\n core.$ZodVoid.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.voidProcessor(inst, ctx, json, params);\n});\nfunction _void(params) {\n return core._void(ZodVoid, params);\n}\nexport { _void as void };\nexport const ZodDate = /*@__PURE__*/ core.$constructor(\"ZodDate\", (inst, def) => {\n core.$ZodDate.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.dateProcessor(inst, ctx, json, params);\n inst.min = (value, params) => inst.check(checks.gte(value, params));\n inst.max = (value, params) => inst.check(checks.lte(value, params));\n const c = inst._zod.bag;\n inst.minDate = c.minimum ? new Date(c.minimum) : null;\n inst.maxDate = c.maximum ? new Date(c.maximum) : null;\n});\nexport function date(params) {\n return core._date(ZodDate, params);\n}\nexport const ZodArray = /*@__PURE__*/ core.$constructor(\"ZodArray\", (inst, def) => {\n core.$ZodArray.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.arrayProcessor(inst, ctx, json, params);\n inst.element = def.element;\n inst.min = (minLength, params) => inst.check(checks.minLength(minLength, params));\n inst.nonempty = (params) => inst.check(checks.minLength(1, params));\n inst.max = (maxLength, params) => inst.check(checks.maxLength(maxLength, params));\n inst.length = (len, params) => inst.check(checks.length(len, params));\n inst.unwrap = () => inst.element;\n});\nexport function array(element, params) {\n return core._array(ZodArray, element, params);\n}\n// .keyof\nexport function keyof(schema) {\n const shape = schema._zod.def.shape;\n return _enum(Object.keys(shape));\n}\nexport const ZodObject = /*@__PURE__*/ core.$constructor(\"ZodObject\", (inst, def) => {\n core.$ZodObjectJIT.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.objectProcessor(inst, ctx, json, params);\n util.defineLazy(inst, \"shape\", () => {\n return def.shape;\n });\n inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));\n inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall });\n inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });\n inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });\n inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });\n inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });\n inst.extend = (incoming) => {\n return util.extend(inst, incoming);\n };\n inst.safeExtend = (incoming) => {\n return util.safeExtend(inst, incoming);\n };\n inst.merge = (other) => util.merge(inst, other);\n inst.pick = (mask) => util.pick(inst, mask);\n inst.omit = (mask) => util.omit(inst, mask);\n inst.partial = (...args) => util.partial(ZodOptional, inst, args[0]);\n inst.required = (...args) => util.required(ZodNonOptional, inst, args[0]);\n});\nexport function object(shape, params) {\n const def = {\n type: \"object\",\n shape: shape ?? {},\n ...util.normalizeParams(params),\n };\n return new ZodObject(def);\n}\n// strictObject\nexport function strictObject(shape, params) {\n return new ZodObject({\n type: \"object\",\n shape,\n catchall: never(),\n ...util.normalizeParams(params),\n });\n}\n// looseObject\nexport function looseObject(shape, params) {\n return new ZodObject({\n type: \"object\",\n shape,\n catchall: unknown(),\n ...util.normalizeParams(params),\n });\n}\nexport const ZodUnion = /*@__PURE__*/ core.$constructor(\"ZodUnion\", (inst, def) => {\n core.$ZodUnion.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);\n inst.options = def.options;\n});\nexport function union(options, params) {\n return new ZodUnion({\n type: \"union\",\n options: options,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodXor = /*@__PURE__*/ core.$constructor(\"ZodXor\", (inst, def) => {\n ZodUnion.init(inst, def);\n core.$ZodXor.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);\n inst.options = def.options;\n});\n/** Creates an exclusive union (XOR) where exactly one option must match.\n * Unlike regular unions that succeed when any option matches, xor fails if\n * zero or more than one option matches the input. */\nexport function xor(options, params) {\n return new ZodXor({\n type: \"union\",\n options: options,\n inclusive: false,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodDiscriminatedUnion = /*@__PURE__*/ core.$constructor(\"ZodDiscriminatedUnion\", (inst, def) => {\n ZodUnion.init(inst, def);\n core.$ZodDiscriminatedUnion.init(inst, def);\n});\nexport function discriminatedUnion(discriminator, options, params) {\n // const [options, params] = args;\n return new ZodDiscriminatedUnion({\n type: \"union\",\n options,\n discriminator,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodIntersection = /*@__PURE__*/ core.$constructor(\"ZodIntersection\", (inst, def) => {\n core.$ZodIntersection.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.intersectionProcessor(inst, ctx, json, params);\n});\nexport function intersection(left, right) {\n return new ZodIntersection({\n type: \"intersection\",\n left: left,\n right: right,\n });\n}\nexport const ZodTuple = /*@__PURE__*/ core.$constructor(\"ZodTuple\", (inst, def) => {\n core.$ZodTuple.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.tupleProcessor(inst, ctx, json, params);\n inst.rest = (rest) => inst.clone({\n ...inst._zod.def,\n rest: rest,\n });\n});\nexport function tuple(items, _paramsOrRest, _params) {\n const hasRest = _paramsOrRest instanceof core.$ZodType;\n const params = hasRest ? _params : _paramsOrRest;\n const rest = hasRest ? _paramsOrRest : null;\n return new ZodTuple({\n type: \"tuple\",\n items: items,\n rest,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodRecord = /*@__PURE__*/ core.$constructor(\"ZodRecord\", (inst, def) => {\n core.$ZodRecord.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.recordProcessor(inst, ctx, json, params);\n inst.keyType = def.keyType;\n inst.valueType = def.valueType;\n});\nexport function record(keyType, valueType, params) {\n return new ZodRecord({\n type: \"record\",\n keyType,\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\n// type alksjf = core.output;\nexport function partialRecord(keyType, valueType, params) {\n const k = core.clone(keyType);\n k._zod.values = undefined;\n return new ZodRecord({\n type: \"record\",\n keyType: k,\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\nexport function looseRecord(keyType, valueType, params) {\n return new ZodRecord({\n type: \"record\",\n keyType,\n valueType: valueType,\n mode: \"loose\",\n ...util.normalizeParams(params),\n });\n}\nexport const ZodMap = /*@__PURE__*/ core.$constructor(\"ZodMap\", (inst, def) => {\n core.$ZodMap.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);\n inst.keyType = def.keyType;\n inst.valueType = def.valueType;\n inst.min = (...args) => inst.check(core._minSize(...args));\n inst.nonempty = (params) => inst.check(core._minSize(1, params));\n inst.max = (...args) => inst.check(core._maxSize(...args));\n inst.size = (...args) => inst.check(core._size(...args));\n});\nexport function map(keyType, valueType, params) {\n return new ZodMap({\n type: \"map\",\n keyType: keyType,\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodSet = /*@__PURE__*/ core.$constructor(\"ZodSet\", (inst, def) => {\n core.$ZodSet.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.setProcessor(inst, ctx, json, params);\n inst.min = (...args) => inst.check(core._minSize(...args));\n inst.nonempty = (params) => inst.check(core._minSize(1, params));\n inst.max = (...args) => inst.check(core._maxSize(...args));\n inst.size = (...args) => inst.check(core._size(...args));\n});\nexport function set(valueType, params) {\n return new ZodSet({\n type: \"set\",\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodEnum = /*@__PURE__*/ core.$constructor(\"ZodEnum\", (inst, def) => {\n core.$ZodEnum.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.enumProcessor(inst, ctx, json, params);\n inst.enum = def.entries;\n inst.options = Object.values(def.entries);\n const keys = new Set(Object.keys(def.entries));\n inst.extract = (values, params) => {\n const newEntries = {};\n for (const value of values) {\n if (keys.has(value)) {\n newEntries[value] = def.entries[value];\n }\n else\n throw new Error(`Key ${value} not found in enum`);\n }\n return new ZodEnum({\n ...def,\n checks: [],\n ...util.normalizeParams(params),\n entries: newEntries,\n });\n };\n inst.exclude = (values, params) => {\n const newEntries = { ...def.entries };\n for (const value of values) {\n if (keys.has(value)) {\n delete newEntries[value];\n }\n else\n throw new Error(`Key ${value} not found in enum`);\n }\n return new ZodEnum({\n ...def,\n checks: [],\n ...util.normalizeParams(params),\n entries: newEntries,\n });\n };\n});\nfunction _enum(values, params) {\n const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n return new ZodEnum({\n type: \"enum\",\n entries,\n ...util.normalizeParams(params),\n });\n}\nexport { _enum as enum };\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport function nativeEnum(entries, params) {\n return new ZodEnum({\n type: \"enum\",\n entries,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodLiteral = /*@__PURE__*/ core.$constructor(\"ZodLiteral\", (inst, def) => {\n core.$ZodLiteral.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.literalProcessor(inst, ctx, json, params);\n inst.values = new Set(def.values);\n Object.defineProperty(inst, \"value\", {\n get() {\n if (def.values.length > 1) {\n throw new Error(\"This schema contains multiple valid literal values. Use `.values` instead.\");\n }\n return def.values[0];\n },\n });\n});\nexport function literal(value, params) {\n return new ZodLiteral({\n type: \"literal\",\n values: Array.isArray(value) ? value : [value],\n ...util.normalizeParams(params),\n });\n}\nexport const ZodFile = /*@__PURE__*/ core.$constructor(\"ZodFile\", (inst, def) => {\n core.$ZodFile.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.fileProcessor(inst, ctx, json, params);\n inst.min = (size, params) => inst.check(core._minSize(size, params));\n inst.max = (size, params) => inst.check(core._maxSize(size, params));\n inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));\n});\nexport function file(params) {\n return core._file(ZodFile, params);\n}\nexport const ZodTransform = /*@__PURE__*/ core.$constructor(\"ZodTransform\", (inst, def) => {\n core.$ZodTransform.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.transformProcessor(inst, ctx, json, params);\n inst._zod.parse = (payload, _ctx) => {\n if (_ctx.direction === \"backward\") {\n throw new core.$ZodEncodeError(inst.constructor.name);\n }\n payload.addIssue = (issue) => {\n if (typeof issue === \"string\") {\n payload.issues.push(util.issue(issue, payload.value, def));\n }\n else {\n // for Zod 3 backwards compatibility\n const _issue = issue;\n if (_issue.fatal)\n _issue.continue = false;\n _issue.code ?? (_issue.code = \"custom\");\n _issue.input ?? (_issue.input = payload.value);\n _issue.inst ?? (_issue.inst = inst);\n // _issue.continue ??= true;\n payload.issues.push(util.issue(_issue));\n }\n };\n const output = def.transform(payload.value, payload);\n if (output instanceof Promise) {\n return output.then((output) => {\n payload.value = output;\n return payload;\n });\n }\n payload.value = output;\n return payload;\n };\n});\nexport function transform(fn) {\n return new ZodTransform({\n type: \"transform\",\n transform: fn,\n });\n}\nexport const ZodOptional = /*@__PURE__*/ core.$constructor(\"ZodOptional\", (inst, def) => {\n core.$ZodOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function optional(innerType) {\n return new ZodOptional({\n type: \"optional\",\n innerType: innerType,\n });\n}\nexport const ZodExactOptional = /*@__PURE__*/ core.$constructor(\"ZodExactOptional\", (inst, def) => {\n core.$ZodExactOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function exactOptional(innerType) {\n return new ZodExactOptional({\n type: \"optional\",\n innerType: innerType,\n });\n}\nexport const ZodNullable = /*@__PURE__*/ core.$constructor(\"ZodNullable\", (inst, def) => {\n core.$ZodNullable.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nullableProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function nullable(innerType) {\n return new ZodNullable({\n type: \"nullable\",\n innerType: innerType,\n });\n}\n// nullish\nexport function nullish(innerType) {\n return optional(nullable(innerType));\n}\nexport const ZodDefault = /*@__PURE__*/ core.$constructor(\"ZodDefault\", (inst, def) => {\n core.$ZodDefault.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.defaultProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n inst.removeDefault = inst.unwrap;\n});\nexport function _default(innerType, defaultValue) {\n return new ZodDefault({\n type: \"default\",\n innerType: innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n },\n });\n}\nexport const ZodPrefault = /*@__PURE__*/ core.$constructor(\"ZodPrefault\", (inst, def) => {\n core.$ZodPrefault.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.prefaultProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function prefault(innerType, defaultValue) {\n return new ZodPrefault({\n type: \"prefault\",\n innerType: innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n },\n });\n}\nexport const ZodNonOptional = /*@__PURE__*/ core.$constructor(\"ZodNonOptional\", (inst, def) => {\n core.$ZodNonOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nonoptionalProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function nonoptional(innerType, params) {\n return new ZodNonOptional({\n type: \"nonoptional\",\n innerType: innerType,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodSuccess = /*@__PURE__*/ core.$constructor(\"ZodSuccess\", (inst, def) => {\n core.$ZodSuccess.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.successProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function success(innerType) {\n return new ZodSuccess({\n type: \"success\",\n innerType: innerType,\n });\n}\nexport const ZodCatch = /*@__PURE__*/ core.$constructor(\"ZodCatch\", (inst, def) => {\n core.$ZodCatch.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.catchProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n inst.removeCatch = inst.unwrap;\n});\nfunction _catch(innerType, catchValue) {\n return new ZodCatch({\n type: \"catch\",\n innerType: innerType,\n catchValue: (typeof catchValue === \"function\" ? catchValue : () => catchValue),\n });\n}\nexport { _catch as catch };\nexport const ZodNaN = /*@__PURE__*/ core.$constructor(\"ZodNaN\", (inst, def) => {\n core.$ZodNaN.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nanProcessor(inst, ctx, json, params);\n});\nexport function nan(params) {\n return core._nan(ZodNaN, params);\n}\nexport const ZodPipe = /*@__PURE__*/ core.$constructor(\"ZodPipe\", (inst, def) => {\n core.$ZodPipe.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.pipeProcessor(inst, ctx, json, params);\n inst.in = def.in;\n inst.out = def.out;\n});\nexport function pipe(in_, out) {\n return new ZodPipe({\n type: \"pipe\",\n in: in_,\n out: out,\n // ...util.normalizeParams(params),\n });\n}\nexport const ZodCodec = /*@__PURE__*/ core.$constructor(\"ZodCodec\", (inst, def) => {\n ZodPipe.init(inst, def);\n core.$ZodCodec.init(inst, def);\n});\nexport function codec(in_, out, params) {\n return new ZodCodec({\n type: \"pipe\",\n in: in_,\n out: out,\n transform: params.decode,\n reverseTransform: params.encode,\n });\n}\nexport const ZodReadonly = /*@__PURE__*/ core.$constructor(\"ZodReadonly\", (inst, def) => {\n core.$ZodReadonly.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.readonlyProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function readonly(innerType) {\n return new ZodReadonly({\n type: \"readonly\",\n innerType: innerType,\n });\n}\nexport const ZodTemplateLiteral = /*@__PURE__*/ core.$constructor(\"ZodTemplateLiteral\", (inst, def) => {\n core.$ZodTemplateLiteral.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.templateLiteralProcessor(inst, ctx, json, params);\n});\nexport function templateLiteral(parts, params) {\n return new ZodTemplateLiteral({\n type: \"template_literal\",\n parts,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodLazy = /*@__PURE__*/ core.$constructor(\"ZodLazy\", (inst, def) => {\n core.$ZodLazy.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.lazyProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.getter();\n});\nexport function lazy(getter) {\n return new ZodLazy({\n type: \"lazy\",\n getter: getter,\n });\n}\nexport const ZodPromise = /*@__PURE__*/ core.$constructor(\"ZodPromise\", (inst, def) => {\n core.$ZodPromise.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.promiseProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function promise(innerType) {\n return new ZodPromise({\n type: \"promise\",\n innerType: innerType,\n });\n}\nexport const ZodFunction = /*@__PURE__*/ core.$constructor(\"ZodFunction\", (inst, def) => {\n core.$ZodFunction.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.functionProcessor(inst, ctx, json, params);\n});\nexport function _function(params) {\n return new ZodFunction({\n type: \"function\",\n input: Array.isArray(params?.input) ? tuple(params?.input) : (params?.input ?? array(unknown())),\n output: params?.output ?? unknown(),\n });\n}\nexport { _function as function };\nexport const ZodCustom = /*@__PURE__*/ core.$constructor(\"ZodCustom\", (inst, def) => {\n core.$ZodCustom.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);\n});\n// custom checks\nexport function check(fn) {\n const ch = new core.$ZodCheck({\n check: \"custom\",\n // ...util.normalizeParams(params),\n });\n ch._zod.check = fn;\n return ch;\n}\nexport function custom(fn, _params) {\n return core._custom(ZodCustom, fn ?? (() => true), _params);\n}\nexport function refine(fn, _params = {}) {\n return core._refine(ZodCustom, fn, _params);\n}\n// superRefine\nexport function superRefine(fn) {\n return core._superRefine(fn);\n}\n// Re-export describe and meta from core\nexport const describe = core.describe;\nexport const meta = core.meta;\nfunction _instanceof(cls, params = {}) {\n const inst = new ZodCustom({\n type: \"custom\",\n check: \"custom\",\n fn: (data) => data instanceof cls,\n abort: true,\n ...util.normalizeParams(params),\n });\n inst._zod.bag.Class = cls;\n // Override check to emit invalid_type instead of custom\n inst._zod.check = (payload) => {\n if (!(payload.value instanceof cls)) {\n payload.issues.push({\n code: \"invalid_type\",\n expected: cls.name,\n input: payload.value,\n inst,\n path: [...(inst._zod.def.path ?? [])],\n });\n }\n };\n return inst;\n}\nexport { _instanceof as instanceof };\n// stringbool\nexport const stringbool = (...args) => core._stringbool({\n Codec: ZodCodec,\n Boolean: ZodBoolean,\n String: ZodString,\n}, ...args);\nexport function json(params) {\n const jsonSchema = lazy(() => {\n return union([string(params), number(), boolean(), _null(), array(jsonSchema), record(string(), jsonSchema)]);\n });\n return jsonSchema;\n}\n// preprocess\n// /** @deprecated Use `z.pipe()` and `z.transform()` instead. */\nexport function preprocess(fn, schema) {\n return pipe(transform(fn), schema);\n}\n", "export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, } from \"../core/index.js\";\n", "import * as core from \"../core/index.js\";\nimport * as schemas from \"./schemas.js\";\nexport const ZodISODateTime = /*@__PURE__*/ core.$constructor(\"ZodISODateTime\", (inst, def) => {\n core.$ZodISODateTime.init(inst, def);\n schemas.ZodStringFormat.init(inst, def);\n});\nexport function datetime(params) {\n return core._isoDateTime(ZodISODateTime, params);\n}\nexport const ZodISODate = /*@__PURE__*/ core.$constructor(\"ZodISODate\", (inst, def) => {\n core.$ZodISODate.init(inst, def);\n schemas.ZodStringFormat.init(inst, def);\n});\nexport function date(params) {\n return core._isoDate(ZodISODate, params);\n}\nexport const ZodISOTime = /*@__PURE__*/ core.$constructor(\"ZodISOTime\", (inst, def) => {\n core.$ZodISOTime.init(inst, def);\n schemas.ZodStringFormat.init(inst, def);\n});\nexport function time(params) {\n return core._isoTime(ZodISOTime, params);\n}\nexport const ZodISODuration = /*@__PURE__*/ core.$constructor(\"ZodISODuration\", (inst, def) => {\n core.$ZodISODuration.init(inst, def);\n schemas.ZodStringFormat.init(inst, def);\n});\nexport function duration(params) {\n return core._isoDuration(ZodISODuration, params);\n}\n", "import * as core from \"../core/index.js\";\nimport { $ZodError } from \"../core/index.js\";\nimport * as util from \"../core/util.js\";\nconst initializer = (inst, issues) => {\n $ZodError.init(inst, issues);\n inst.name = \"ZodError\";\n Object.defineProperties(inst, {\n format: {\n value: (mapper) => core.formatError(inst, mapper),\n // enumerable: false,\n },\n flatten: {\n value: (mapper) => core.flattenError(inst, mapper),\n // enumerable: false,\n },\n addIssue: {\n value: (issue) => {\n inst.issues.push(issue);\n inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);\n },\n // enumerable: false,\n },\n addIssues: {\n value: (issues) => {\n inst.issues.push(...issues);\n inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);\n },\n // enumerable: false,\n },\n isEmpty: {\n get() {\n return inst.issues.length === 0;\n },\n // enumerable: false,\n },\n });\n // Object.defineProperty(inst, \"isEmpty\", {\n // get() {\n // return inst.issues.length === 0;\n // },\n // });\n};\nexport const ZodError = core.$constructor(\"ZodError\", initializer);\nexport const ZodRealError = core.$constructor(\"ZodError\", initializer, {\n Parent: Error,\n});\n// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */\n// export type ErrorMapCtx = core.$ZodErrorMapCtx;\n", "import * as core from \"../core/index.js\";\nimport { ZodRealError } from \"./errors.js\";\nexport const parse = /* @__PURE__ */ core._parse(ZodRealError);\nexport const parseAsync = /* @__PURE__ */ core._parseAsync(ZodRealError);\nexport const safeParse = /* @__PURE__ */ core._safeParse(ZodRealError);\nexport const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodRealError);\n// Codec functions\nexport const encode = /* @__PURE__ */ core._encode(ZodRealError);\nexport const decode = /* @__PURE__ */ core._decode(ZodRealError);\nexport const encodeAsync = /* @__PURE__ */ core._encodeAsync(ZodRealError);\nexport const decodeAsync = /* @__PURE__ */ core._decodeAsync(ZodRealError);\nexport const safeEncode = /* @__PURE__ */ core._safeEncode(ZodRealError);\nexport const safeDecode = /* @__PURE__ */ core._safeDecode(ZodRealError);\nexport const safeEncodeAsync = /* @__PURE__ */ core._safeEncodeAsync(ZodRealError);\nexport const safeDecodeAsync = /* @__PURE__ */ core._safeDecodeAsync(ZodRealError);\n", "// Zod 3 compat layer\nimport * as core from \"../core/index.js\";\n/** @deprecated Use the raw string literal codes instead, e.g. \"invalid_type\". */\nexport const ZodIssueCode = {\n invalid_type: \"invalid_type\",\n too_big: \"too_big\",\n too_small: \"too_small\",\n invalid_format: \"invalid_format\",\n not_multiple_of: \"not_multiple_of\",\n unrecognized_keys: \"unrecognized_keys\",\n invalid_union: \"invalid_union\",\n invalid_key: \"invalid_key\",\n invalid_element: \"invalid_element\",\n invalid_value: \"invalid_value\",\n custom: \"custom\",\n};\nexport { $brand, config } from \"../core/index.js\";\n/** @deprecated Use `z.config(params)` instead. */\nexport function setErrorMap(map) {\n core.config({\n customError: map,\n });\n}\n/** @deprecated Use `z.config()` instead. */\nexport function getErrorMap() {\n return core.config().customError;\n}\n/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */\nexport var ZodFirstPartyTypeKind;\n(function (ZodFirstPartyTypeKind) {\n})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));\n", "import { globalRegistry } from \"../core/registries.js\";\nimport * as _checks from \"./checks.js\";\nimport * as _iso from \"./iso.js\";\nimport * as _schemas from \"./schemas.js\";\n// Local z object to avoid circular dependency with ../index.js\nconst z = {\n ..._schemas,\n ..._checks,\n iso: _iso,\n};\n// Keys that are recognized and handled by the conversion logic\nconst RECOGNIZED_KEYS = new Set([\n // Schema identification\n \"$schema\",\n \"$ref\",\n \"$defs\",\n \"definitions\",\n // Core schema keywords\n \"$id\",\n \"id\",\n \"$comment\",\n \"$anchor\",\n \"$vocabulary\",\n \"$dynamicRef\",\n \"$dynamicAnchor\",\n // Type\n \"type\",\n \"enum\",\n \"const\",\n // Composition\n \"anyOf\",\n \"oneOf\",\n \"allOf\",\n \"not\",\n // Object\n \"properties\",\n \"required\",\n \"additionalProperties\",\n \"patternProperties\",\n \"propertyNames\",\n \"minProperties\",\n \"maxProperties\",\n // Array\n \"items\",\n \"prefixItems\",\n \"additionalItems\",\n \"minItems\",\n \"maxItems\",\n \"uniqueItems\",\n \"contains\",\n \"minContains\",\n \"maxContains\",\n // String\n \"minLength\",\n \"maxLength\",\n \"pattern\",\n \"format\",\n // Number\n \"minimum\",\n \"maximum\",\n \"exclusiveMinimum\",\n \"exclusiveMaximum\",\n \"multipleOf\",\n // Already handled metadata\n \"description\",\n \"default\",\n // Content\n \"contentEncoding\",\n \"contentMediaType\",\n \"contentSchema\",\n // Unsupported (error-throwing)\n \"unevaluatedItems\",\n \"unevaluatedProperties\",\n \"if\",\n \"then\",\n \"else\",\n \"dependentSchemas\",\n \"dependentRequired\",\n // OpenAPI\n \"nullable\",\n \"readOnly\",\n]);\nfunction detectVersion(schema, defaultTarget) {\n const $schema = schema.$schema;\n if ($schema === \"https://json-schema.org/draft/2020-12/schema\") {\n return \"draft-2020-12\";\n }\n if ($schema === \"http://json-schema.org/draft-07/schema#\") {\n return \"draft-7\";\n }\n if ($schema === \"http://json-schema.org/draft-04/schema#\") {\n return \"draft-4\";\n }\n // Use defaultTarget if provided, otherwise default to draft-2020-12\n return defaultTarget ?? \"draft-2020-12\";\n}\nfunction resolveRef(ref, ctx) {\n if (!ref.startsWith(\"#\")) {\n throw new Error(\"External $ref is not supported, only local refs (#/...) are allowed\");\n }\n const path = ref.slice(1).split(\"/\").filter(Boolean);\n // Handle root reference \"#\"\n if (path.length === 0) {\n return ctx.rootSchema;\n }\n const defsKey = ctx.version === \"draft-2020-12\" ? \"$defs\" : \"definitions\";\n if (path[0] === defsKey) {\n const key = path[1];\n if (!key || !ctx.defs[key]) {\n throw new Error(`Reference not found: ${ref}`);\n }\n return ctx.defs[key];\n }\n throw new Error(`Reference not found: ${ref}`);\n}\nfunction convertBaseSchema(schema, ctx) {\n // Handle unsupported features\n if (schema.not !== undefined) {\n // Special case: { not: {} } represents never\n if (typeof schema.not === \"object\" && Object.keys(schema.not).length === 0) {\n return z.never();\n }\n throw new Error(\"not is not supported in Zod (except { not: {} } for never)\");\n }\n if (schema.unevaluatedItems !== undefined) {\n throw new Error(\"unevaluatedItems is not supported\");\n }\n if (schema.unevaluatedProperties !== undefined) {\n throw new Error(\"unevaluatedProperties is not supported\");\n }\n if (schema.if !== undefined || schema.then !== undefined || schema.else !== undefined) {\n throw new Error(\"Conditional schemas (if/then/else) are not supported\");\n }\n if (schema.dependentSchemas !== undefined || schema.dependentRequired !== undefined) {\n throw new Error(\"dependentSchemas and dependentRequired are not supported\");\n }\n // Handle $ref\n if (schema.$ref) {\n const refPath = schema.$ref;\n if (ctx.refs.has(refPath)) {\n return ctx.refs.get(refPath);\n }\n if (ctx.processing.has(refPath)) {\n // Circular reference - use lazy\n return z.lazy(() => {\n if (!ctx.refs.has(refPath)) {\n throw new Error(`Circular reference not resolved: ${refPath}`);\n }\n return ctx.refs.get(refPath);\n });\n }\n ctx.processing.add(refPath);\n const resolved = resolveRef(refPath, ctx);\n const zodSchema = convertSchema(resolved, ctx);\n ctx.refs.set(refPath, zodSchema);\n ctx.processing.delete(refPath);\n return zodSchema;\n }\n // Handle enum\n if (schema.enum !== undefined) {\n const enumValues = schema.enum;\n // Special case: OpenAPI 3.0 null representation { type: \"string\", nullable: true, enum: [null] }\n if (ctx.version === \"openapi-3.0\" &&\n schema.nullable === true &&\n enumValues.length === 1 &&\n enumValues[0] === null) {\n return z.null();\n }\n if (enumValues.length === 0) {\n return z.never();\n }\n if (enumValues.length === 1) {\n return z.literal(enumValues[0]);\n }\n // Check if all values are strings\n if (enumValues.every((v) => typeof v === \"string\")) {\n return z.enum(enumValues);\n }\n // Mixed types - use union of literals\n const literalSchemas = enumValues.map((v) => z.literal(v));\n if (literalSchemas.length < 2) {\n return literalSchemas[0];\n }\n return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);\n }\n // Handle const\n if (schema.const !== undefined) {\n return z.literal(schema.const);\n }\n // Handle type\n const type = schema.type;\n if (Array.isArray(type)) {\n // Expand type array into anyOf union\n const typeSchemas = type.map((t) => {\n const typeSchema = { ...schema, type: t };\n return convertBaseSchema(typeSchema, ctx);\n });\n if (typeSchemas.length === 0) {\n return z.never();\n }\n if (typeSchemas.length === 1) {\n return typeSchemas[0];\n }\n return z.union(typeSchemas);\n }\n if (!type) {\n // No type specified - empty schema (any)\n return z.any();\n }\n let zodSchema;\n switch (type) {\n case \"string\": {\n let stringSchema = z.string();\n // Apply format using .check() with Zod format functions\n if (schema.format) {\n const format = schema.format;\n // Map common formats to Zod check functions\n if (format === \"email\") {\n stringSchema = stringSchema.check(z.email());\n }\n else if (format === \"uri\" || format === \"uri-reference\") {\n stringSchema = stringSchema.check(z.url());\n }\n else if (format === \"uuid\" || format === \"guid\") {\n stringSchema = stringSchema.check(z.uuid());\n }\n else if (format === \"date-time\") {\n stringSchema = stringSchema.check(z.iso.datetime());\n }\n else if (format === \"date\") {\n stringSchema = stringSchema.check(z.iso.date());\n }\n else if (format === \"time\") {\n stringSchema = stringSchema.check(z.iso.time());\n }\n else if (format === \"duration\") {\n stringSchema = stringSchema.check(z.iso.duration());\n }\n else if (format === \"ipv4\") {\n stringSchema = stringSchema.check(z.ipv4());\n }\n else if (format === \"ipv6\") {\n stringSchema = stringSchema.check(z.ipv6());\n }\n else if (format === \"mac\") {\n stringSchema = stringSchema.check(z.mac());\n }\n else if (format === \"cidr\") {\n stringSchema = stringSchema.check(z.cidrv4());\n }\n else if (format === \"cidr-v6\") {\n stringSchema = stringSchema.check(z.cidrv6());\n }\n else if (format === \"base64\") {\n stringSchema = stringSchema.check(z.base64());\n }\n else if (format === \"base64url\") {\n stringSchema = stringSchema.check(z.base64url());\n }\n else if (format === \"e164\") {\n stringSchema = stringSchema.check(z.e164());\n }\n else if (format === \"jwt\") {\n stringSchema = stringSchema.check(z.jwt());\n }\n else if (format === \"emoji\") {\n stringSchema = stringSchema.check(z.emoji());\n }\n else if (format === \"nanoid\") {\n stringSchema = stringSchema.check(z.nanoid());\n }\n else if (format === \"cuid\") {\n stringSchema = stringSchema.check(z.cuid());\n }\n else if (format === \"cuid2\") {\n stringSchema = stringSchema.check(z.cuid2());\n }\n else if (format === \"ulid\") {\n stringSchema = stringSchema.check(z.ulid());\n }\n else if (format === \"xid\") {\n stringSchema = stringSchema.check(z.xid());\n }\n else if (format === \"ksuid\") {\n stringSchema = stringSchema.check(z.ksuid());\n }\n // Note: json-string format is not currently supported by Zod\n // Custom formats are ignored - keep as plain string\n }\n // Apply constraints\n if (typeof schema.minLength === \"number\") {\n stringSchema = stringSchema.min(schema.minLength);\n }\n if (typeof schema.maxLength === \"number\") {\n stringSchema = stringSchema.max(schema.maxLength);\n }\n if (schema.pattern) {\n // JSON Schema patterns are not implicitly anchored (match anywhere in string)\n stringSchema = stringSchema.regex(new RegExp(schema.pattern));\n }\n zodSchema = stringSchema;\n break;\n }\n case \"number\":\n case \"integer\": {\n let numberSchema = type === \"integer\" ? z.number().int() : z.number();\n // Apply constraints\n if (typeof schema.minimum === \"number\") {\n numberSchema = numberSchema.min(schema.minimum);\n }\n if (typeof schema.maximum === \"number\") {\n numberSchema = numberSchema.max(schema.maximum);\n }\n if (typeof schema.exclusiveMinimum === \"number\") {\n numberSchema = numberSchema.gt(schema.exclusiveMinimum);\n }\n else if (schema.exclusiveMinimum === true && typeof schema.minimum === \"number\") {\n numberSchema = numberSchema.gt(schema.minimum);\n }\n if (typeof schema.exclusiveMaximum === \"number\") {\n numberSchema = numberSchema.lt(schema.exclusiveMaximum);\n }\n else if (schema.exclusiveMaximum === true && typeof schema.maximum === \"number\") {\n numberSchema = numberSchema.lt(schema.maximum);\n }\n if (typeof schema.multipleOf === \"number\") {\n numberSchema = numberSchema.multipleOf(schema.multipleOf);\n }\n zodSchema = numberSchema;\n break;\n }\n case \"boolean\": {\n zodSchema = z.boolean();\n break;\n }\n case \"null\": {\n zodSchema = z.null();\n break;\n }\n case \"object\": {\n const shape = {};\n const properties = schema.properties || {};\n const requiredSet = new Set(schema.required || []);\n // Convert properties - mark optional ones\n for (const [key, propSchema] of Object.entries(properties)) {\n const propZodSchema = convertSchema(propSchema, ctx);\n // If not in required array, make it optional\n shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();\n }\n // Handle propertyNames\n if (schema.propertyNames) {\n const keySchema = convertSchema(schema.propertyNames, ctx);\n const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === \"object\"\n ? convertSchema(schema.additionalProperties, ctx)\n : z.any();\n // Case A: No properties (pure record)\n if (Object.keys(shape).length === 0) {\n zodSchema = z.record(keySchema, valueSchema);\n break;\n }\n // Case B: With properties (intersection of object and looseRecord)\n const objectSchema = z.object(shape).passthrough();\n const recordSchema = z.looseRecord(keySchema, valueSchema);\n zodSchema = z.intersection(objectSchema, recordSchema);\n break;\n }\n // Handle patternProperties\n if (schema.patternProperties) {\n // patternProperties: keys matching pattern must satisfy corresponding schema\n // Use loose records so non-matching keys pass through\n const patternProps = schema.patternProperties;\n const patternKeys = Object.keys(patternProps);\n const looseRecords = [];\n for (const pattern of patternKeys) {\n const patternValue = convertSchema(patternProps[pattern], ctx);\n const keySchema = z.string().regex(new RegExp(pattern));\n looseRecords.push(z.looseRecord(keySchema, patternValue));\n }\n // Build intersection: object schema + all pattern property records\n const schemasToIntersect = [];\n if (Object.keys(shape).length > 0) {\n // Use passthrough so patternProperties can validate additional keys\n schemasToIntersect.push(z.object(shape).passthrough());\n }\n schemasToIntersect.push(...looseRecords);\n if (schemasToIntersect.length === 0) {\n zodSchema = z.object({}).passthrough();\n }\n else if (schemasToIntersect.length === 1) {\n zodSchema = schemasToIntersect[0];\n }\n else {\n // Chain intersections: (A & B) & C & D ...\n let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);\n for (let i = 2; i < schemasToIntersect.length; i++) {\n result = z.intersection(result, schemasToIntersect[i]);\n }\n zodSchema = result;\n }\n break;\n }\n // Handle additionalProperties\n // In JSON Schema, additionalProperties defaults to true (allow any extra properties)\n // In Zod, objects strip unknown keys by default, so we need to handle this explicitly\n const objectSchema = z.object(shape);\n if (schema.additionalProperties === false) {\n // Strict mode - no extra properties allowed\n zodSchema = objectSchema.strict();\n }\n else if (typeof schema.additionalProperties === \"object\") {\n // Extra properties must match the specified schema\n zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));\n }\n else {\n // additionalProperties is true or undefined - allow any extra properties (passthrough)\n zodSchema = objectSchema.passthrough();\n }\n break;\n }\n case \"array\": {\n // TODO: uniqueItems is not supported\n // TODO: contains/minContains/maxContains are not supported\n // Check if this is a tuple (prefixItems or items as array)\n const prefixItems = schema.prefixItems;\n const items = schema.items;\n if (prefixItems && Array.isArray(prefixItems)) {\n // Tuple with prefixItems (draft-2020-12)\n const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));\n const rest = items && typeof items === \"object\" && !Array.isArray(items)\n ? convertSchema(items, ctx)\n : undefined;\n if (rest) {\n zodSchema = z.tuple(tupleItems).rest(rest);\n }\n else {\n zodSchema = z.tuple(tupleItems);\n }\n // Apply minItems/maxItems constraints to tuples\n if (typeof schema.minItems === \"number\") {\n zodSchema = zodSchema.check(z.minLength(schema.minItems));\n }\n if (typeof schema.maxItems === \"number\") {\n zodSchema = zodSchema.check(z.maxLength(schema.maxItems));\n }\n }\n else if (Array.isArray(items)) {\n // Tuple with items array (draft-7)\n const tupleItems = items.map((item) => convertSchema(item, ctx));\n const rest = schema.additionalItems && typeof schema.additionalItems === \"object\"\n ? convertSchema(schema.additionalItems, ctx)\n : undefined; // additionalItems: false means no rest, handled by default tuple behavior\n if (rest) {\n zodSchema = z.tuple(tupleItems).rest(rest);\n }\n else {\n zodSchema = z.tuple(tupleItems);\n }\n // Apply minItems/maxItems constraints to tuples\n if (typeof schema.minItems === \"number\") {\n zodSchema = zodSchema.check(z.minLength(schema.minItems));\n }\n if (typeof schema.maxItems === \"number\") {\n zodSchema = zodSchema.check(z.maxLength(schema.maxItems));\n }\n }\n else if (items !== undefined) {\n // Regular array\n const element = convertSchema(items, ctx);\n let arraySchema = z.array(element);\n // Apply constraints\n if (typeof schema.minItems === \"number\") {\n arraySchema = arraySchema.min(schema.minItems);\n }\n if (typeof schema.maxItems === \"number\") {\n arraySchema = arraySchema.max(schema.maxItems);\n }\n zodSchema = arraySchema;\n }\n else {\n // No items specified - array of any\n zodSchema = z.array(z.any());\n }\n break;\n }\n default:\n throw new Error(`Unsupported type: ${type}`);\n }\n // Apply metadata\n if (schema.description) {\n zodSchema = zodSchema.describe(schema.description);\n }\n if (schema.default !== undefined) {\n zodSchema = zodSchema.default(schema.default);\n }\n return zodSchema;\n}\nfunction convertSchema(schema, ctx) {\n if (typeof schema === \"boolean\") {\n return schema ? z.any() : z.never();\n }\n // Convert base schema first (ignoring composition keywords)\n let baseSchema = convertBaseSchema(schema, ctx);\n const hasExplicitType = schema.type || schema.enum !== undefined || schema.const !== undefined;\n // Process composition keywords LAST (they can appear together)\n // Handle anyOf - wrap base schema with union\n if (schema.anyOf && Array.isArray(schema.anyOf)) {\n const options = schema.anyOf.map((s) => convertSchema(s, ctx));\n const anyOfUnion = z.union(options);\n baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;\n }\n // Handle oneOf - exclusive union (exactly one must match)\n if (schema.oneOf && Array.isArray(schema.oneOf)) {\n const options = schema.oneOf.map((s) => convertSchema(s, ctx));\n const oneOfUnion = z.xor(options);\n baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;\n }\n // Handle allOf - wrap base schema with intersection\n if (schema.allOf && Array.isArray(schema.allOf)) {\n if (schema.allOf.length === 0) {\n baseSchema = hasExplicitType ? baseSchema : z.any();\n }\n else {\n let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);\n const startIdx = hasExplicitType ? 0 : 1;\n for (let i = startIdx; i < schema.allOf.length; i++) {\n result = z.intersection(result, convertSchema(schema.allOf[i], ctx));\n }\n baseSchema = result;\n }\n }\n // Handle nullable (OpenAPI 3.0)\n if (schema.nullable === true && ctx.version === \"openapi-3.0\") {\n baseSchema = z.nullable(baseSchema);\n }\n // Handle readOnly\n if (schema.readOnly === true) {\n baseSchema = z.readonly(baseSchema);\n }\n // Collect metadata: core schema keywords and unrecognized keys\n const extraMeta = {};\n // Core schema keywords that should be captured as metadata\n const coreMetadataKeys = [\"$id\", \"id\", \"$comment\", \"$anchor\", \"$vocabulary\", \"$dynamicRef\", \"$dynamicAnchor\"];\n for (const key of coreMetadataKeys) {\n if (key in schema) {\n extraMeta[key] = schema[key];\n }\n }\n // Content keywords - store as metadata\n const contentMetadataKeys = [\"contentEncoding\", \"contentMediaType\", \"contentSchema\"];\n for (const key of contentMetadataKeys) {\n if (key in schema) {\n extraMeta[key] = schema[key];\n }\n }\n // Unrecognized keys (custom metadata)\n for (const key of Object.keys(schema)) {\n if (!RECOGNIZED_KEYS.has(key)) {\n extraMeta[key] = schema[key];\n }\n }\n if (Object.keys(extraMeta).length > 0) {\n ctx.registry.add(baseSchema, extraMeta);\n }\n return baseSchema;\n}\n/**\n * Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */\nexport function fromJSONSchema(schema, params) {\n // Handle boolean schemas\n if (typeof schema === \"boolean\") {\n return schema ? z.any() : z.never();\n }\n const version = detectVersion(schema, params?.defaultTarget);\n const defs = (schema.$defs || schema.definitions || {});\n const ctx = {\n version,\n defs,\n refs: new Map(),\n processing: new Set(),\n rootSchema: schema,\n registry: params?.registry ?? globalRegistry,\n };\n return convertSchema(schema, ctx);\n}\n", "export * as core from \"../core/index.js\";\nexport * from \"./schemas.js\";\nexport * from \"./checks.js\";\nexport * from \"./errors.js\";\nexport * from \"./parse.js\";\nexport * from \"./compat.js\";\n// zod-specified\nimport { config } from \"../core/index.js\";\nimport en from \"../locales/en.js\";\nconfig(en());\nexport { globalRegistry, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from \"../core/index.js\";\nexport { toJSONSchema } from \"../core/json-schema-processors.js\";\nexport { fromJSONSchema } from \"./from-json-schema.js\";\nexport * as locales from \"../locales/index.js\";\n// iso\n// must be exported from top-level\n// https://github.com/colinhacks/zod/issues/4491\nexport { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from \"./iso.js\";\nexport * as iso from \"./iso.js\";\nexport * as coerce from \"./coerce.js\";\n", null, null, "export const ignoreOverride = Symbol(\"Let zodToJsonSchema decide on which parser to use\");\nexport const jsonDescription = (jsonSchema, def) => {\n if (def.description) {\n try {\n return {\n ...jsonSchema,\n ...JSON.parse(def.description),\n };\n }\n catch { }\n }\n return jsonSchema;\n};\nexport const defaultOptions = {\n name: undefined,\n $refStrategy: \"root\",\n basePath: [\"#\"],\n effectStrategy: \"input\",\n pipeStrategy: \"all\",\n dateStrategy: \"format:date-time\",\n mapStrategy: \"entries\",\n removeAdditionalStrategy: \"passthrough\",\n allowedAdditionalProperties: true,\n rejectedAdditionalProperties: false,\n definitionPath: \"definitions\",\n target: \"jsonSchema7\",\n strictUnions: false,\n definitions: {},\n errorMessages: false,\n markdownDescription: false,\n patternStrategy: \"escape\",\n applyRegexFlags: false,\n emailStrategy: \"format:email\",\n base64Strategy: \"contentEncoding:base64\",\n nameStrategy: \"ref\",\n openAiAnyTypeName: \"OpenAiAnyType\"\n};\nexport const getDefaultOptions = (options) => (typeof options === \"string\"\n ? {\n ...defaultOptions,\n name: options,\n }\n : {\n ...defaultOptions,\n ...options,\n });\n", "import { setResponseValueAndErrors } from \"../errorMessages.js\";\nlet emojiRegex = undefined;\n/**\n * Generated from the regular expressions found here as of 2024-05-22:\n * https://github.com/colinhacks/zod/blob/master/src/types.ts.\n *\n * Expressions with /i flag have been changed accordingly.\n */\nexport const zodPatterns = {\n /**\n * `c` was changed to `[cC]` to replicate /i flag\n */\n cuid: /^[cC][^\\s-]{8,}$/,\n cuid2: /^[0-9a-z]+$/,\n ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,\n /**\n * `a-z` was added to replicate /i flag\n */\n email: /^(?!\\.)(?!.*\\.\\.)([a-zA-Z0-9_'+\\-\\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\\-]*\\.)+[a-zA-Z]{2,}$/,\n /**\n * Constructed a valid Unicode RegExp\n *\n * Lazily instantiate since this type of regex isn't supported\n * in all envs (e.g. React Native).\n *\n * See:\n * https://github.com/colinhacks/zod/issues/2433\n * Fix in Zod:\n * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b\n */\n emoji: () => {\n if (emojiRegex === undefined) {\n emojiRegex = RegExp(\"^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$\", \"u\");\n }\n return emojiRegex;\n },\n /**\n * Unused\n */\n uuid: /^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$/,\n /**\n * Unused\n */\n ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,\n ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/(3[0-2]|[12]?[0-9])$/,\n /**\n * Unused\n */\n ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,\n ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,\n base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,\n base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,\n nanoid: /^[a-zA-Z0-9_-]{21}$/,\n jwt: /^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$/,\n};\nexport function parseStringDef(def, refs) {\n const res = {\n type: \"string\",\n };\n if (def.checks) {\n for (const check of def.checks) {\n switch (check.kind) {\n case \"min\":\n setResponseValueAndErrors(res, \"minLength\", typeof res.minLength === \"number\"\n ? Math.max(res.minLength, check.value)\n : check.value, check.message, refs);\n break;\n case \"max\":\n setResponseValueAndErrors(res, \"maxLength\", typeof res.maxLength === \"number\"\n ? Math.min(res.maxLength, check.value)\n : check.value, check.message, refs);\n break;\n case \"email\":\n switch (refs.emailStrategy) {\n case \"format:email\":\n addFormat(res, \"email\", check.message, refs);\n break;\n case \"format:idn-email\":\n addFormat(res, \"idn-email\", check.message, refs);\n break;\n case \"pattern:zod\":\n addPattern(res, zodPatterns.email, check.message, refs);\n break;\n }\n break;\n case \"url\":\n addFormat(res, \"uri\", check.message, refs);\n break;\n case \"uuid\":\n addFormat(res, \"uuid\", check.message, refs);\n break;\n case \"regex\":\n addPattern(res, check.regex, check.message, refs);\n break;\n case \"cuid\":\n addPattern(res, zodPatterns.cuid, check.message, refs);\n break;\n case \"cuid2\":\n addPattern(res, zodPatterns.cuid2, check.message, refs);\n break;\n case \"startsWith\":\n addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);\n break;\n case \"endsWith\":\n addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);\n break;\n case \"datetime\":\n addFormat(res, \"date-time\", check.message, refs);\n break;\n case \"date\":\n addFormat(res, \"date\", check.message, refs);\n break;\n case \"time\":\n addFormat(res, \"time\", check.message, refs);\n break;\n case \"duration\":\n addFormat(res, \"duration\", check.message, refs);\n break;\n case \"length\":\n setResponseValueAndErrors(res, \"minLength\", typeof res.minLength === \"number\"\n ? Math.max(res.minLength, check.value)\n : check.value, check.message, refs);\n setResponseValueAndErrors(res, \"maxLength\", typeof res.maxLength === \"number\"\n ? Math.min(res.maxLength, check.value)\n : check.value, check.message, refs);\n break;\n case \"includes\": {\n addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);\n break;\n }\n case \"ip\": {\n if (check.version !== \"v6\") {\n addFormat(res, \"ipv4\", check.message, refs);\n }\n if (check.version !== \"v4\") {\n addFormat(res, \"ipv6\", check.message, refs);\n }\n break;\n }\n case \"base64url\":\n addPattern(res, zodPatterns.base64url, check.message, refs);\n break;\n case \"jwt\":\n addPattern(res, zodPatterns.jwt, check.message, refs);\n break;\n case \"cidr\": {\n if (check.version !== \"v6\") {\n addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);\n }\n if (check.version !== \"v4\") {\n addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);\n }\n break;\n }\n case \"emoji\":\n addPattern(res, zodPatterns.emoji(), check.message, refs);\n break;\n case \"ulid\": {\n addPattern(res, zodPatterns.ulid, check.message, refs);\n break;\n }\n case \"base64\": {\n switch (refs.base64Strategy) {\n case \"format:binary\": {\n addFormat(res, \"binary\", check.message, refs);\n break;\n }\n case \"contentEncoding:base64\": {\n setResponseValueAndErrors(res, \"contentEncoding\", \"base64\", check.message, refs);\n break;\n }\n case \"pattern:zod\": {\n addPattern(res, zodPatterns.base64, check.message, refs);\n break;\n }\n }\n break;\n }\n case \"nanoid\": {\n addPattern(res, zodPatterns.nanoid, check.message, refs);\n }\n case \"toLowerCase\":\n case \"toUpperCase\":\n case \"trim\":\n break;\n default:\n ((_) => { })(check);\n }\n }\n }\n return res;\n}\nfunction escapeLiteralCheckValue(literal, refs) {\n return refs.patternStrategy === \"escape\"\n ? escapeNonAlphaNumeric(literal)\n : literal;\n}\nconst ALPHA_NUMERIC = new Set(\"ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789\");\nfunction escapeNonAlphaNumeric(source) {\n let result = \"\";\n for (let i = 0; i < source.length; i++) {\n if (!ALPHA_NUMERIC.has(source[i])) {\n result += \"\\\\\";\n }\n result += source[i];\n }\n return result;\n}\n// Adds a \"format\" keyword to the schema. If a format exists, both formats will be joined in an allOf-node, along with subsequent ones.\nfunction addFormat(schema, value, message, refs) {\n if (schema.format || schema.anyOf?.some((x) => x.format)) {\n if (!schema.anyOf) {\n schema.anyOf = [];\n }\n if (schema.format) {\n schema.anyOf.push({\n format: schema.format,\n ...(schema.errorMessage &&\n refs.errorMessages && {\n errorMessage: { format: schema.errorMessage.format },\n }),\n });\n delete schema.format;\n if (schema.errorMessage) {\n delete schema.errorMessage.format;\n if (Object.keys(schema.errorMessage).length === 0) {\n delete schema.errorMessage;\n }\n }\n }\n schema.anyOf.push({\n format: value,\n ...(message &&\n refs.errorMessages && { errorMessage: { format: message } }),\n });\n }\n else {\n setResponseValueAndErrors(schema, \"format\", value, message, refs);\n }\n}\n// Adds a \"pattern\" keyword to the schema. If a pattern exists, both patterns will be joined in an allOf-node, along with subsequent ones.\nfunction addPattern(schema, regex, message, refs) {\n if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {\n if (!schema.allOf) {\n schema.allOf = [];\n }\n if (schema.pattern) {\n schema.allOf.push({\n pattern: schema.pattern,\n ...(schema.errorMessage &&\n refs.errorMessages && {\n errorMessage: { pattern: schema.errorMessage.pattern },\n }),\n });\n delete schema.pattern;\n if (schema.errorMessage) {\n delete schema.errorMessage.pattern;\n if (Object.keys(schema.errorMessage).length === 0) {\n delete schema.errorMessage;\n }\n }\n }\n schema.allOf.push({\n pattern: stringifyRegExpWithFlags(regex, refs),\n ...(message &&\n refs.errorMessages && { errorMessage: { pattern: message } }),\n });\n }\n else {\n setResponseValueAndErrors(schema, \"pattern\", stringifyRegExpWithFlags(regex, refs), message, refs);\n }\n}\n// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true\nfunction stringifyRegExpWithFlags(regex, refs) {\n if (!refs.applyRegexFlags || !regex.flags) {\n return regex.source;\n }\n // Currently handled flags\n const flags = {\n i: regex.flags.includes(\"i\"),\n m: regex.flags.includes(\"m\"),\n s: regex.flags.includes(\"s\"), // `.` matches newlines\n };\n // The general principle here is to step through each character, one at a time, applying mutations as flags require. We keep track when the current character is escaped, and when it's inside a group /like [this]/ or (also) a range like /[a-z]/. The following is fairly brittle imperative code; edit at your peril!\n const source = flags.i ? regex.source.toLowerCase() : regex.source;\n let pattern = \"\";\n let isEscaped = false;\n let inCharGroup = false;\n let inCharRange = false;\n for (let i = 0; i < source.length; i++) {\n if (isEscaped) {\n pattern += source[i];\n isEscaped = false;\n continue;\n }\n if (flags.i) {\n if (inCharGroup) {\n if (source[i].match(/[a-z]/)) {\n if (inCharRange) {\n pattern += source[i];\n pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();\n inCharRange = false;\n }\n else if (source[i + 1] === \"-\" && source[i + 2]?.match(/[a-z]/)) {\n pattern += source[i];\n inCharRange = true;\n }\n else {\n pattern += `${source[i]}${source[i].toUpperCase()}`;\n }\n continue;\n }\n }\n else if (source[i].match(/[a-z]/)) {\n pattern += `[${source[i]}${source[i].toUpperCase()}]`;\n continue;\n }\n }\n if (flags.m) {\n if (source[i] === \"^\") {\n pattern += `(^|(?<=[\\r\\n]))`;\n continue;\n }\n else if (source[i] === \"$\") {\n pattern += `($|(?=[\\r\\n]))`;\n continue;\n }\n }\n if (flags.s && source[i] === \".\") {\n pattern += inCharGroup ? `${source[i]}\\r\\n` : `[${source[i]}\\r\\n]`;\n continue;\n }\n pattern += source[i];\n if (source[i] === \"\\\\\") {\n isEscaped = true;\n }\n else if (inCharGroup && source[i] === \"]\") {\n inCharGroup = false;\n }\n else if (!inCharGroup && source[i] === \"[\") {\n inCharGroup = true;\n }\n }\n try {\n new RegExp(pattern);\n }\n catch {\n console.warn(`Could not convert regex pattern at ${refs.currentPath.join(\"/\")} to a flag-independent form! Falling back to the flag-ignorant source`);\n return regex.source;\n }\n return pattern;\n}\n", null, null, null, null, null, null, null, null, "import * as fs from 'fs/promises';\nimport * as crypto from 'crypto';\nimport {ENV_FILE, formatChannel, HOST, TOKENS_FILE,CONFIG} from \"./config.js\";\n\n// Function to generate a secure random token\nfunction generateToken() {\n return crypto.randomBytes(16).toString('hex');\n}\n\n\n// Authorized channel-token pairs - Only channels with valid tokens can connect\n// Format: { \"/channel1\": \"token123\" }\nlet authorizedTokens = {};\n\nfunction getToken(channel) {\n return authorizedTokens[channel];\n}\n\nfunction setToken(channel, value) {\n authorizedTokens[channel] = value;\n}\n\nfunction deleteToken(channel) {\n delete authorizedTokens[channel];\n}\n\nfunction clearTokens(channel) {\n authorizedTokens = {};\n}\n\n// Load authorized tokens from disk\nasync function loadAuthorizedTokens() {\n try {\n const data = await fs.readFile(TOKENS_FILE, 'utf8');\n authorizedTokens = JSON.parse(data || \"{}\");\n\n // console.error(`Loaded ${Object.keys(authorizedTokens).length} authorized channel-token pairs from ${TOKENS_FILE}`);\n return true;\n } catch (error) {\n // If file doesn't exist, start with empty tokens\n if (error.code === 'ENOENT') {\n authorizedTokens = {};\n return true;\n }\n console.error('Error loading authorized tokens:', error);\n return false;\n }\n}\n\n// Save authorized tokens to disk\nasync function saveAuthorizedTokens() {\n try {\n // Convert Map to object for JSON serialization\n const stringified = JSON.stringify(authorizedTokens, null, 2);\n await fs.writeFile(TOKENS_FILE, stringified, 'utf8');\n // console.error(`Saved ${stringified} authorized channel-token pairs to ${TOKENS_FILE}`);\n return true;\n } catch (error) {\n console.error('Error saving authorized tokens:', error);\n return false;\n }\n}\n\n// Function to save server token to .env file\nasync function saveServerTokenToEnv(token) {\n try {\n let envContent = '';\n\n try {\n // Try to read existing .env file\n envContent = await fs.readFile(ENV_FILE, 'utf8');\n\n // Check if WEBMCP_SERVER_TOKEN is already defined\n if (envContent.includes('WEBMCP_SERVER_TOKEN=')) {\n // Replace the existing token\n envContent = envContent.replace(/WEBMCP_SERVER_TOKEN=.*(\\r?\\n|$)/g, `WEBMCP_SERVER_TOKEN=${token}$1`);\n } else {\n // Add the token to the end\n envContent += `\\nWEBMCP_SERVER_TOKEN=${token}\\n`;\n }\n } catch (err) {\n // File doesn't exist, create new content\n envContent = `WEBMCP_SERVER_TOKEN=${token}\\n`;\n }\n\n // Write the content to the .env file\n await fs.writeFile(ENV_FILE, envContent, 'utf8');\n console.error(`Server token saved to ${ENV_FILE}`);\n return true;\n } catch (error) {\n console.error('Error saving server token to .env file:', error);\n return false;\n }\n}\n\nasync function generateNewRegistrationToken() {\n // Generate a random token for registration\n const token = generateToken();\n\n // Create a connection object with server address and token\n const address = `${HOST}:${CONFIG.port}`;\n const serverAddress = `ws://${address}`;\n const connectionData = {\n server: serverAddress,\n token: token\n };\n\n // Convert to JSON and base64 encode\n const jsonStr = JSON.stringify(connectionData);\n const encodedData = Buffer.from(jsonStr).toString('base64');\n\n setToken(formatChannel(address), token);\n await saveAuthorizedTokens();\n\n return encodedData;\n}\n\nexport {generateToken, getToken, setToken, loadAuthorizedTokens, saveAuthorizedTokens, clearTokens, deleteToken, saveServerTokenToEnv, generateNewRegistrationToken};\n", "import * as path from 'path';\nimport * as dotenv from 'dotenv';\nimport * as os from 'os';\nimport * as fs from 'fs/promises';\nimport envPaths from 'env-paths';\n\n// Create config directory in user's home folder\nconst HOME_DIR = os.homedir();\nconst CONFIG_DIR = path.join(HOME_DIR, '.webmcp');\n\n// Ensure config directory exists\nconst ensureConfigDir = async () => {\n try {\n await fs.mkdir(CONFIG_DIR, {recursive: true});\n } catch (error) {\n console.error(`Error creating config directory at ${CONFIG_DIR}:`, error);\n }\n};\n\n// Process ID file path\nconst PID_FILE = path.join(CONFIG_DIR, '.webmcp-server.pid');\n// Environment file path\nconst ENV_FILE = path.join(CONFIG_DIR, '.env');\n// Tokens file path\nconst TOKENS_FILE = path.join(CONFIG_DIR, '.webmcp-tokens.json');\n\n// Load environment variables\ndotenv.config({path: ENV_FILE});\n\n// Server token for MCP authentication\nconst SERVER_TOKEN = process.env.WEBMCP_SERVER_TOKEN || '';\n\nconst HOST = \"localhost\";\n\nconst CONFIG = {};\n\nfunction setConfig(args) {\n Object.entries(args).forEach(([key, value]) => {\n CONFIG[key] = value;\n });\n}\n\nfunction formatChannel(channel) {\n return `/${channel.replace(/[.:]/g, '_')}`\n}\n\nasync function exists(somePath) {\n try {\n await fs.access(somePath);\n return true;\n } catch (e) {\n return false;\n }\n}\n\nasync function configureMcpClientWithPath(clientConfigPath) {\n const directory = path.dirname(clientConfigPath);\n if (!await exists(directory)) {\n await fs.mkdir(directory, { recursive: true });\n }\n\n const webmcpConfig = {\n \"webmcp\": {\n \"command\": \"npx\",\n \"args\": [\n \"-y\",\n \"@nucleoriofrio/webmcp@latest\",\n \"--mcp\"\n ]\n }\n };\n\n let json = { mcpServers: {} };\n\n // If one already exists, we'll want to update it\n if (await exists(clientConfigPath)) {\n const rawJSON = await fs.readFile(clientConfigPath);\n try {\n json = JSON.parse(rawJSON);\n } catch (e) {\n throw new Error(`Failed to update MCP client configuration: ${e}`);\n }\n }\n\n json.mcpServers = { ...json.mcpServers, ...webmcpConfig};\n await fs.writeFile(clientConfigPath, JSON.stringify(json, null, 2));\n}\n\nconst availableClientConfigs = {\n \"claude\": [envPaths(\"Claude\", { suffix: \"\" }).data, \"claude_desktop_config.json\"],\n \"cline\": [envPaths(\"Code\", { suffix: \"\" }).data, \"User\", \"globalStorage\", \"saoudrizwan.claude-dev\", \"settings\", \"cline_mcp_settings.json\"],\n \"cursor\": [HOME_DIR, \".cursor\", \"mcp.json\"],\n \"windsurf\": [HOME_DIR, \".codeium\", \"windsurf\", \"mcp_config.json\"]\n};\n\nasync function configureMcpClient(clientType) {\n let clientConfigPath = availableClientConfigs[clientType];\n if (clientConfigPath) {\n await configureMcpClientWithPath(clientConfigPath);\n } else {\n console.error(\"Unsupported client - treating it like a path...\")\n await configureMcpClientWithPath(clientType);\n }\n}\n\nexport {\n CONFIG,\n HOST,\n PID_FILE,\n ENV_FILE,\n TOKENS_FILE,\n SERVER_TOKEN,\n ensureConfigDir,\n formatChannel,\n setConfig,\n configureMcpClientWithPath,\n configureMcpClient,\n};\n", "import path from 'node:path';\nimport os from 'node:os';\nimport process from 'node:process';\n\nconst homedir = os.homedir();\nconst tmpdir = os.tmpdir();\nconst {env} = process;\n\nconst macos = name => {\n\tconst library = path.join(homedir, 'Library');\n\n\treturn {\n\t\tdata: path.join(library, 'Application Support', name),\n\t\tconfig: path.join(library, 'Preferences', name),\n\t\tcache: path.join(library, 'Caches', name),\n\t\tlog: path.join(library, 'Logs', name),\n\t\ttemp: path.join(tmpdir, name),\n\t};\n};\n\nconst windows = name => {\n\tconst appData = env.APPDATA || path.join(homedir, 'AppData', 'Roaming');\n\tconst localAppData = env.LOCALAPPDATA || path.join(homedir, 'AppData', 'Local');\n\n\treturn {\n\t\t// Data/config/cache/log are invented by me as Windows isn't opinionated about this\n\t\tdata: path.join(localAppData, name, 'Data'),\n\t\tconfig: path.join(appData, name, 'Config'),\n\t\tcache: path.join(localAppData, name, 'Cache'),\n\t\tlog: path.join(localAppData, name, 'Log'),\n\t\ttemp: path.join(tmpdir, name),\n\t};\n};\n\n// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html\nconst linux = name => {\n\tconst username = path.basename(homedir);\n\n\treturn {\n\t\tdata: path.join(env.XDG_DATA_HOME || path.join(homedir, '.local', 'share'), name),\n\t\tconfig: path.join(env.XDG_CONFIG_HOME || path.join(homedir, '.config'), name),\n\t\tcache: path.join(env.XDG_CACHE_HOME || path.join(homedir, '.cache'), name),\n\t\t// https://wiki.debian.org/XDGBaseDirectorySpecification#state\n\t\tlog: path.join(env.XDG_STATE_HOME || path.join(homedir, '.local', 'state'), name),\n\t\ttemp: path.join(tmpdir, username, name),\n\t};\n};\n\nexport default function envPaths(name, {suffix = 'nodejs'} = {}) {\n\tif (typeof name !== 'string') {\n\t\tthrow new TypeError(`Expected a string, got ${typeof name}`);\n\t}\n\n\tif (suffix) {\n\t\t// Add suffix to prevent possible conflict with native apps\n\t\tname += `-${suffix}`;\n\t}\n\n\tif (process.platform === 'darwin') {\n\t\treturn macos(name);\n\t}\n\n\tif (process.platform === 'win32') {\n\t\treturn windows(name);\n\t}\n\n\treturn linux(name);\n}\n", "import {Server} from \"@modelcontextprotocol/sdk/server/index.js\";\nimport {StdioServerTransport} from '@modelcontextprotocol/sdk/server/stdio.js';\nimport WebSocket from 'ws';\nimport {\n CallToolRequestSchema,\n CreateMessageRequestSchema,\n GetPromptRequestSchema,\n ListPromptsRequestSchema,\n ListResourcesRequestSchema,\n ListResourceTemplatesRequestSchema,\n ListToolsRequestSchema,\n ReadResourceRequestSchema\n} from '@modelcontextprotocol/sdk/types.js';\nimport {generateNewRegistrationToken} from \"./tokens.js\";\nimport {CONFIG} from \"./config.js\";\nimport {execSync} from \"child_process\";\n\n// Create a central MCP server that communicates over stdio\nconst mcpServer = new Server(\n {\n name: \"@nucleoriofrio/webmcp\",\n version: \"0.2.0\",\n },\n {\n capabilities: {\n tools: {\n listChanged: true\n },\n prompts: {\n listChanged: true\n },\n resources: {\n listChanged: true,\n subscribe: true\n },\n sampling: {}\n }\n }\n);\n\n// WebSocket client connection\nlet wsClient = null;\n\n// MCP specific channel path\nconst MCP_PATH = '/mcp';\n\n// Map to store pending requests from WebSocket to MCP\nconst pendingRequests = new Map();\nlet requestIdCounter = 1;\n\n// Debounce timers for list changed notifications\nlet toolListChangedTimer = null;\nlet promptListChangedTimer = null;\nlet resourceListChangedTimer = null;\nconst LIST_CHANGED_DEBOUNCE_MS = 500;\n\nfunction debouncedToolListChanged() {\n if (toolListChangedTimer) clearTimeout(toolListChangedTimer);\n toolListChangedTimer = setTimeout(async () => {\n toolListChangedTimer = null;\n try { await mcpServer.sendToolListChanged(); } catch (e) { console.error('Error sending tool list changed:', e); }\n }, LIST_CHANGED_DEBOUNCE_MS);\n}\n\nfunction debouncedPromptListChanged() {\n if (promptListChangedTimer) clearTimeout(promptListChangedTimer);\n promptListChangedTimer = setTimeout(async () => {\n promptListChangedTimer = null;\n try { await mcpServer.sendPromptListChanged(); } catch (e) { console.error('Error sending prompt list changed:', e); }\n }, LIST_CHANGED_DEBOUNCE_MS);\n}\n\nfunction debouncedResourceListChanged() {\n if (resourceListChangedTimer) clearTimeout(resourceListChangedTimer);\n resourceListChangedTimer = setTimeout(async () => {\n resourceListChangedTimer = null;\n try { await mcpServer.sendResourceListChanged(); } catch (e) { console.error('Error sending resource list changed:', e); }\n }, LIST_CHANGED_DEBOUNCE_MS);\n}\n\n// Function to handle WebSocket messages\nasync function handleWebSocketMessage(message) {\n try {\n const data = JSON.parse(message);\n console.error(`Received message: ${data.type}`);\n\n if (data.type === 'toolResponse') {\n // Handle tool response from WebSocket server\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (pendingRequests.has(id)) {\n const {resolve, reject} = pendingRequests.get(id);\n pendingRequests.delete(id);\n\n if (error) {\n reject(new Error(error));\n } else {\n resolve(result);\n }\n } else {\n console.error(`No pending request found for ID: ${id}`);\n }\n } else if (data.type === 'promptResponse') {\n // Handle prompt response from WebSocket server\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (pendingRequests.has(id)) {\n const {resolve, reject} = pendingRequests.get(id);\n pendingRequests.delete(id);\n\n if (error) {\n reject(new Error(error));\n } else {\n resolve(result);\n }\n } else {\n console.error(`No pending request found for ID: ${id}`);\n }\n } else if (data.type === 'resourceResponse') {\n // Handle resource response from WebSocket server\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (pendingRequests.has(id)) {\n const {resolve, reject} = pendingRequests.get(id);\n pendingRequests.delete(id);\n\n if (error) {\n reject(new Error(error));\n } else {\n resolve(result);\n }\n } else {\n console.error(`No pending request found for ID: ${id}`);\n }\n } else if (data.type === 'samplingResponse') {\n // Handle sampling response from WebSocket server\n const {id, result, error} = data;\n\n // Check if this is a response to a pending request\n if (pendingRequests.has(id)) {\n const {resolve, reject} = pendingRequests.get(id);\n pendingRequests.delete(id);\n\n if (error) {\n reject(new Error(error));\n } else {\n resolve(result);\n }\n } else {\n console.error(`No pending request found for ID: ${id}`);\n }\n } else if (data.type === 'listToolsResponse') {\n // Handle list tools response from WebSocket server\n const {id, tools, error} = data;\n\n // Check if this is a response to a pending request\n if (pendingRequests.has(id)) {\n const {resolve, reject} = pendingRequests.get(id);\n pendingRequests.delete(id);\n\n if (error) {\n reject(new Error(error));\n } else {\n resolve(tools);\n }\n } else {\n console.error(`No pending request found for ID: ${id}`);\n }\n } else if (data.type === 'listPromptsResponse') {\n // Handle list prompts response from WebSocket server\n const {id, prompts, error} = data;\n\n // Check if this is a response to a pending request\n if (pendingRequests.has(id)) {\n const {resolve, reject} = pendingRequests.get(id);\n pendingRequests.delete(id);\n\n if (error) {\n reject(new Error(error));\n } else {\n resolve(prompts);\n }\n } else {\n console.error(`No pending request found for ID: ${id}`);\n }\n } else if (data.type === 'listResourcesResponse') {\n // Handle list resources response from WebSocket server\n const {id, resources, resourceTemplates, error} = data;\n\n // Check if this is a response to a pending request\n if (pendingRequests.has(id)) {\n const {resolve, reject} = pendingRequests.get(id);\n pendingRequests.delete(id);\n\n if (error) {\n reject(new Error(error));\n } else {\n resolve({resources, resourceTemplates});\n }\n } else {\n console.error(`No pending request found for ID: ${id}`);\n }\n } else if (data.type === 'toolRegistered') {\n debouncedToolListChanged();\n } else if (data.type === 'resourceRegistered') {\n debouncedResourceListChanged();\n } else if (data.type === 'promptRegistered') {\n debouncedPromptListChanged();\n } else if (data.type === 'welcome') {\n // Welcome message from the server, we're already connected to the MCP path\n console.error(`Connected to path: ${data.channel}`);\n } else if (data.type === 'pong') {\n // Pong response\n console.error(`Received pong with timestamp: ${data.timestamp}`);\n } else if (data.type === 'error') {\n // Error message\n console.error(`Received error: ${data.message}`);\n }\n } catch (error) {\n console.error('Error processing WebSocket message:', error);\n }\n}\n\n// Function to connect to the WebSocket server\nfunction connectToWebSocketServer(serverToken) {\n // Connect to the MCP path directly with server token\n const serverUrl = `ws://localhost:${CONFIG.port}${MCP_PATH}?token=${serverToken}`;\n\n console.error(`Connecting to WebSocket server at ${MCP_PATH} with authentication...`);\n\n wsClient = new WebSocket(serverUrl);\n\n // Handle connection opening\n wsClient.on('open', () => {\n console.error(`Connected to WebSocket server on path: ${MCP_PATH}`);\n });\n\n // Handle incoming messages\n wsClient.on('message', (message) => {\n handleWebSocketMessage(message);\n });\n\n // Handle connection closing\n wsClient.on('close', (code, reason) => {\n console.error(`WebSocket connection closed: ${code} ${reason}`);\n wsClient = null;\n\n // Try to reconnect after a delay\n setTimeout(connectToWebSocketServer, 5000);\n });\n\n // Handle connection errors\n wsClient.on('error', (error) => {\n console.error('WebSocket connection error:', error);\n });\n}\n\n// Function to send a message to the WebSocket server\nfunction sendMessage(message) {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n console.error('Cannot send message: WebSocket not connected');\n return Promise.reject(new Error('WebSocket not connected'));\n }\n\n try {\n wsClient.send(JSON.stringify(message));\n return Promise.resolve();\n } catch (error) {\n console.error('Error sending message:', error);\n return Promise.reject(error);\n }\n}\n\n// Set up the MCP server to handle tool calls by sending them to the WebSocket server\nmcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {\n if (request.params.name === \"_webmcp_get-token\") {\n const token = await generateNewRegistrationToken();\n\n // Copiar token al portapapeles del sistema\n try {\n execSync('clip.exe', { input: token, stdio: ['pipe', 'ignore', 'ignore'] });\n } catch (e) {\n try {\n execSync('xclip -selection clipboard', { input: token, stdio: ['pipe', 'ignore', 'ignore'] });\n } catch (e2) {\n // No hay clipboard disponible\n }\n }\n\n // Enviar token a los navegadores conectados para copiar al portapapeles\n try {\n await sendMessage({\n type: 'clipboardCopy',\n text: token\n });\n } catch (e) {\n // Ignorar si no hay clientes conectados\n }\n\n return {\n content: [{\n type: \"text\",\n text: `Token copiado al portapapeles.\\n${token}`,\n }]\n };\n }\n\n if (request.params.name === \"_webmcp_clear-cache\") {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return { content: [{ type: \"text\", text: \"No hay conexion al servidor WebSocket\" }], isError: true };\n }\n\n const requestId = (requestIdCounter++).toString();\n const responsePromise = new Promise((resolve, reject) => {\n pendingRequests.set(requestId, { resolve, reject });\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('Clear cache timeout'));\n }\n }, 10000);\n });\n\n try {\n await sendMessage({ id: requestId, type: 'clearRegistry' });\n const result = await responsePromise;\n await mcpServer.sendToolListChanged();\n await mcpServer.sendPromptListChanged();\n await mcpServer.sendResourceListChanged();\n return { content: [{ type: \"text\", text: result }] };\n } catch (e) {\n return { content: [{ type: \"text\", text: `Error: ${e.message}` }], isError: true };\n }\n }\n\n if (request.params.name === \"_webmcp_browser-info\") {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return { content: [{ type: \"text\", text: \"No hay conexion al servidor WebSocket\" }], isError: true };\n }\n\n const requestId = (requestIdCounter++).toString();\n const responsePromise = new Promise((resolve, reject) => {\n pendingRequests.set(requestId, { resolve, reject });\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('Timeout obteniendo info de navegadores'));\n }\n }, 10000);\n });\n\n try {\n await sendMessage({ id: requestId, type: 'getClientInfo' });\n const result = await responsePromise;\n return result;\n } catch (e) {\n return { content: [{ type: \"text\", text: `Error: ${e.message}` }], isError: true };\n }\n }\n\n if (request.params.name === \"_webmcp_agregar-tool\") {\n if (!CONFIG.dev) {\n return { content: [{ type: \"text\", text: \"agregar-tool solo esta disponible en modo desarrollo (--dev)\" }], isError: true };\n }\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return { content: [{ type: \"text\", text: \"No hay conexion al servidor WebSocket\" }], isError: true };\n }\n const { nombre, descripcion, codigo, parametros } = request.params.arguments;\n if (!nombre || !descripcion || !codigo) {\n return { content: [{ type: \"text\", text: \"Se requieren: nombre, descripcion y codigo\" }], isError: true };\n }\n\n const requestId = (requestIdCounter++).toString();\n const responsePromise = new Promise((resolve, reject) => {\n pendingRequests.set(requestId, { resolve, reject });\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('Timeout creando herramienta'));\n }\n }, 15000);\n });\n\n try {\n await sendMessage({\n id: requestId,\n type: 'createTool',\n name: nombre,\n description: descripcion,\n code: codigo,\n parametros: parametros\n });\n const result = await responsePromise;\n await mcpServer.sendToolListChanged();\n return result;\n } catch (e) {\n return { content: [{ type: \"text\", text: `Error: ${e.message}` }], isError: true };\n }\n }\n\n if (request.params.name === \"_webmcp_quitar-tool\") {\n if (!CONFIG.dev) {\n return { content: [{ type: \"text\", text: \"quitar-tool solo esta disponible en modo desarrollo (--dev)\" }], isError: true };\n }\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return { content: [{ type: \"text\", text: \"No hay conexion al servidor WebSocket\" }], isError: true };\n }\n const { nombre, listar, todas } = request.params.arguments || {};\n\n const requestId = (requestIdCounter++).toString();\n const responsePromise = new Promise((resolve, reject) => {\n pendingRequests.set(requestId, { resolve, reject });\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('Timeout'));\n }\n }, 10000);\n });\n\n try {\n await sendMessage({\n id: requestId,\n type: 'removeTool',\n name: nombre,\n listar: !!listar,\n todas: !!todas\n });\n const result = await responsePromise;\n await mcpServer.sendToolListChanged();\n return result;\n } catch (e) {\n return { content: [{ type: \"text\", text: `Error: ${e.message}` }], isError: true };\n }\n }\n\n if (request.params.name === \"_webmcp_server-info\") {\n if (!CONFIG.dev) {\n return { content: [{ type: \"text\", text: \"server-info solo esta disponible en modo desarrollo (--dev)\" }], isError: true };\n }\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return { content: [{ type: \"text\", text: \"No hay conexion al servidor WebSocket\" }], isError: true };\n }\n\n const requestId = (requestIdCounter++).toString();\n const responsePromise = new Promise((resolve, reject) => {\n pendingRequests.set(requestId, { resolve, reject });\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('Timeout obteniendo info del servidor'));\n }\n }, 10000);\n });\n\n try {\n await sendMessage({ id: requestId, type: 'getServerInfo' });\n const result = await responsePromise;\n return result;\n } catch (e) {\n return { content: [{ type: \"text\", text: `Error: ${e.message}` }], isError: true };\n }\n }\n\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return {\n content: [{\n type: \"text\",\n text: \"Not connected to WebSocket server\"\n }],\n isError: true\n };\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error(`Tool call timed out: ${request.params.name}`));\n }\n }, 30000); // 30 second timeout\n });\n\n // Send the request to the WebSocket server\n try {\n await sendMessage({\n id: requestId,\n type: 'callTool',\n tool: request.params.name,\n arguments: request.params.arguments\n });\n\n // Wait for the response\n return await responsePromise;\n } catch (error) {\n return {\n content: [{\n type: \"text\",\n text: `Error: ${error.message}`\n }],\n isError: true\n };\n }\n});\n\n// Set up the MCP server to handle list tools by querying the WebSocket server\nmcpServer.setRequestHandler(ListToolsRequestSchema, async () => {\n const builtInTools = [\n {\n name: \"_webmcp_get-token\",\n description: \"Genera un token de conexion para vincular un navegador con @nucleoriofrio/webmcp. El usuario puede decir 'registrar token' o 'conectar webmcp'.\",\n inputSchema: {\n type: \"object\",\n properties: {},\n },\n },\n {\n name: \"_webmcp_clear-cache\",\n description: \"Limpia todas las herramientas, prompts y recursos registrados en el cache del servidor @nucleoriofrio/webmcp. Usar para forzar un estado limpio.\",\n inputSchema: {\n type: \"object\",\n properties: {},\n },\n },\n {\n name: \"_webmcp_browser-info\",\n description: \"Muestra informacion de los navegadores conectados: user agent, URL, hostname, idioma, resolucion y tiempo de conexion.\",\n inputSchema: {\n type: \"object\",\n properties: {},\n },\n },\n ];\n\n // Tools de desarrollo: solo disponibles con --dev o WEBMCP_DEV=true\n if (CONFIG.dev) {\n builtInTools.push(\n {\n name: \"_webmcp_agregar-tool\",\n description: \"[DEV] Registra una nueva herramienta dinamicamente. El agente puede usar esto para crear herramientas nuevas en tiempo real.\",\n inputSchema: {\n type: \"object\",\n properties: {\n nombre: { type: \"string\", description: \"Nombre de la herramienta\" },\n descripcion: { type: \"string\", description: \"Descripcion de lo que hace\" },\n parametros: { type: \"string\", description: \"JSON string con las properties del schema, ej: {\\\"msg\\\":{\\\"type\\\":\\\"string\\\",\\\"description\\\":\\\"mensaje\\\"}}\" },\n codigo: { type: \"string\", description: \"Codigo JavaScript del body de la funcion. Recibe \\\"args\\\" como parametro. Debe retornar un string.\" }\n },\n required: [\"nombre\", \"descripcion\", \"codigo\"]\n },\n },\n {\n name: \"_webmcp_quitar-tool\",\n description: \"[DEV] Desregistra herramientas. Usa listar=true para ver las disponibles, todas=true para quitar todas, o nombre para quitar una especifica.\",\n inputSchema: {\n type: \"object\",\n properties: {\n nombre: { type: \"string\", description: \"Nombre de la herramienta a quitar\" },\n listar: { type: \"boolean\", description: \"Si es true, lista las herramientas en vez de quitar\" },\n todas: { type: \"boolean\", description: \"Si es true, quita todas las herramientas\" }\n }\n },\n },\n {\n name: \"_webmcp_server-info\",\n description: \"[DEV] Muestra estado del servidor @nucleoriofrio/webmcp: version, commit, host, puerto, canales activos, clientes, registry de tools/prompts/resources, uptime y requests pendientes.\",\n inputSchema: {\n type: \"object\",\n properties: {},\n },\n }\n );\n }\n\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return {tools: builtInTools};\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('List tools request timed out'));\n }\n }, 10000); // 10 second timeout\n });\n\n // Send the request to the WebSocket server\n try {\n await sendMessage({\n id: requestId,\n type: 'listTools'\n });\n\n const tools = await responsePromise;\n\n // Wait for the response\n return { tools: [...tools, ...builtInTools] };\n } catch (error) {\n console.error('Error listing tools:', error);\n return {tools: []}; // Return empty list on error\n }\n});\n\n// Set up the MCP server to handle list prompts by querying the WebSocket server\nmcpServer.setRequestHandler(ListPromptsRequestSchema, async () => {\n const builtInPrompts = [];\n\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return {\n prompts: builtInPrompts\n };\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('List prompts request timed out'));\n }\n }, 10000); // 10 second timeout\n });\n\n // Send the request to the WebSocket server\n try {\n await sendMessage({\n id: requestId,\n type: 'listPrompts'\n });\n\n const prompts = await responsePromise;\n\n // Wait for the response\n return {\n prompts: [\n ...prompts,\n ...builtInPrompts\n ],\n };\n } catch (error) {\n console.error('Error listing prompts:', error);\n return {prompts: []}; // Return empty list on error\n }\n});\n\n// Set up the MCP server to handle get prompt by querying the WebSocket server\nmcpServer.setRequestHandler(GetPromptRequestSchema, async (request) => {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n throw new Error(\"Not connected to WebSocket server\");\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error(`Get prompt request timed out: ${request.params.name}`));\n }\n }, 30000); // 30 second timeout\n });\n\n // Send the request to the WebSocket server\n try {\n await sendMessage({\n id: requestId,\n type: 'getPrompt',\n name: request.params.name,\n arguments: request.params.arguments\n });\n\n // Wait for the response\n return await responsePromise;\n } catch (error) {\n console.error('Error getting prompt:', error);\n throw error;\n }\n});\n\n// Set up the MCP server to handle list resources by querying the WebSocket server\nmcpServer.setRequestHandler(ListResourcesRequestSchema, async () => {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return {resources: []};\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('List resources request timed out'));\n }\n }, 10000); // 10 second timeout\n });\n\n // Send the request to the WebSocket server\n try {\n await sendMessage({\n id: requestId,\n type: 'listResources'\n });\n\n const {resources} = await responsePromise;\n\n // Wait for the response\n return {resources};\n } catch (error) {\n console.error('Error listing resources:', error);\n return {resources: []}; // Return empty list on error\n }\n});\n\n// Set up the MCP server to handle list resource templates by querying the WebSocket server\nmcpServer.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n return {resourceTemplates: []};\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error('List resource templates request timed out'));\n }\n }, 10000); // 10 second timeout\n });\n\n // Send the request to the WebSocket server\n try {\n await sendMessage({\n id: requestId,\n type: 'listResources'\n });\n\n const {resourceTemplates} = await responsePromise;\n\n // Wait for the response\n return {resourceTemplates};\n } catch (error) {\n console.error('Error listing resource templates:', error);\n return {resourceTemplates: []}; // Return empty list on error\n }\n});\n\n// Set up the MCP server to handle read resource by querying the WebSocket server\nmcpServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n throw new Error(\"Not connected to WebSocket server\");\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error(`Read resource request timed out: ${request.params.uri}`));\n }\n }, 30000); // 30 second timeout\n });\n\n // Send the request to the WebSocket server\n try {\n await sendMessage({\n id: requestId,\n type: 'readResource',\n uri: request.params.uri\n });\n\n // Wait for the response\n return await responsePromise;\n } catch (error) {\n console.error('Error reading resource:', error);\n throw error;\n }\n});\n\n// Set up the MCP server to handle sampling by querying the WebSocket server\nmcpServer.setRequestHandler(CreateMessageRequestSchema, async (request) => {\n if (!wsClient || wsClient.readyState !== WebSocket.OPEN) {\n throw new Error(\"Not connected to WebSocket server\");\n }\n\n // Create a unique request ID\n const requestId = (requestIdCounter++).toString();\n\n // Create a promise that will be resolved when we get a response\n const responsePromise = new Promise((resolve, reject) => {\n // Store the resolver functions\n pendingRequests.set(requestId, {resolve, reject});\n\n // Set a timeout to prevent hanging requests\n setTimeout(() => {\n if (pendingRequests.has(requestId)) {\n pendingRequests.delete(requestId);\n reject(new Error(`Sampling request timed out`));\n }\n }, 120000); // 120 second timeout (sampling can take longer)\n });\n\n // Send the request to the WebSocket server with all parameters from the request\n try {\n await sendMessage({\n id: requestId,\n type: 'createSamplingMessage',\n messages: request.params.messages,\n systemPrompt: request.params.systemPrompt,\n includeContext: request.params.includeContext,\n temperature: request.params.temperature,\n maxTokens: request.params.maxTokens,\n stopSequences: request.params.stopSequences,\n metadata: request.params.metadata,\n modelPreferences: request.params.modelPreferences\n });\n\n // Wait for the response\n return await responsePromise;\n } catch (error) {\n console.error('Error creating sampling message:', error);\n throw error;\n }\n});\n\nasync function runMcpServer(serverToken) {\n // Connect to the WebSocket server\n connectToWebSocketServer(serverToken);\n const transport = new StdioServerTransport();\n await mcpServer.connect(transport);\n console.error(\"@nucleoriofrio/webmcp v0.2.0 \u2014 MCP server running with stdio transport\");\n if (CONFIG.dev) {\n console.error(\"[DEV] Modo desarrollo activo \u2014 agregar-tool y quitar-tool habilitados\");\n }\n}\n\nexport { runMcpServer };\n"], + "mappings": "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", + "names": ["data", "Receiver", "error", "Sender", "merge", "error", "parse", "randomBytes", "URL", "Receiver", "Sender", "parse", "WebSocket", "key", "WebSocket", "createWebSocketStream", "error", "err", "parse", "protocol", "WebSocket", "WebSocketServer", "version", "map", "_a", "UsedValueState", "_a", "error", "_a", "hash", "mergeValues", "Type", "error", "_a", "DataType", "_a", "env", "_a", "hex", "ipv6", "path", "esc", "path", "wss", "parse", "_a", "Ajv", "meta", "env", "_a", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "error", "DiscrError", "error", "_a", "required", "Ajv", "date", "time", "error", "fs", "_a", "fs", "path", "os", "crypto", "version", "parse", "error", "config", "fs", "WebSocket", "parse", "execSync", "util", "assertIs", "assertNever", "object", "joinValues", "array", "objectUtil", "issue", "error", "issue", "path", "map", "issue", "errorUtil", "path", "error", "errorMap", "check", "transform", "version", "jwt", "base64", "_ZodString", "parsedType", "ctx", "result", "issue", "issues", "elements", "processed", "preprocess", "parsedType", "result", "ZodFirstPartyTypeKind", "initializer", "_a", "floatSafeRemainder", "getParsedType", "array", "set", "object", "path", "Class", "_a", "config", "base64", "base64url", "hex", "error", "issue", "version", "time", "timeRegex", "_a", "inst", "floatSafeRemainder", "result", "_a", "checks", "isAborted", "checkResult", "canary", "result", "_", "url", "base64", "isValidJWT", "r", "isObject", "allowsEval", "results", "map", "left", "right", "mergeValues", "keyResult", "valueResult", "output", "issue", "en_default", "meta", "Class", "Class", "_emoji", "Class", "Class", "Class", "Class", "_undefined", "_null", "Class", "Class", "Class", "Class", "issue", "codec", "process", "_a", "meta", "id", "schema", "json", "file", "process", "safeParse", "result", "def", "schemas_exports", "ZodAny", "ZodArray", "ZodBigInt", "ZodBoolean", "ZodCatch", "ZodDate", "ZodDefault", "ZodDiscriminatedUnion", "ZodEnum", "ZodFunction", "ZodIntersection", "ZodLazy", "ZodLiteral", "ZodMap", "ZodNaN", "ZodNever", "ZodNull", "ZodNullable", "ZodNumber", "ZodObject", "ZodOptional", "ZodPromise", "ZodReadonly", "ZodRecord", "ZodSet", "ZodString", "ZodSymbol", "ZodTuple", "ZodType", "ZodUndefined", "ZodUnion", "ZodUnknown", "ZodVoid", "base64", "base64url", "bigint", "boolean", "cidrv4", "cidrv6", "cuid", "cuid2", "date", "describe", "e164", "email", "emoji", "guid", "hex", "hostname", "ipv4", "ipv6", "ksuid", "mac", "meta", "nanoid", "_null", "nullish", "number", "object", "string", "ulid", "_undefined", "uuid", "_void", "xid", "checks_exports", "iso_exports", "date", "datetime", "duration", "time", "datetime", "date", "time", "duration", "initializer", "issue", "issues", "ZodError", "parse", "parseAsync", "safeParse", "safeParseAsync", "encode", "decode", "encodeAsync", "decodeAsync", "safeEncode", "safeDecode", "safeEncodeAsync", "safeDecodeAsync", "ZodType", "def", "meta", "parse", "safeParse", "parseAsync", "safeParseAsync", "encode", "decode", "encodeAsync", "decodeAsync", "safeEncode", "safeDecode", "safeEncodeAsync", "safeDecodeAsync", "check", "json", "ZodString", "_emoji", "datetime", "date", "time", "duration", "string", "email", "guid", "uuid", "emoji", "nanoid", "cuid", "cuid2", "ulid", "xid", "ksuid", "ipv4", "mac", "ipv6", "cidrv4", "cidrv6", "base64", "base64url", "e164", "hostname", "hex", "ZodNumber", "number", "ZodBoolean", "boolean", "ZodBigInt", "bigint", "ZodSymbol", "ZodUndefined", "_undefined", "ZodNull", "ZodType", "json", "_null", "ZodAny", "ZodType", "json", "ZodUnknown", "ZodNever", "ZodVoid", "_void", "ZodDate", "ZodType", "json", "date", "ZodArray", "ZodObject", "ZodOptional", "object", "ZodUnion", "ZodDiscriminatedUnion", "ZodIntersection", "ZodTuple", "ZodRecord", "ZodMap", "ZodSet", "ZodEnum", "ZodEnum", "ZodLiteral", "ZodType", "json", "issue", "output", "ZodOptional", "ZodNullable", "nullish", "ZodDefault", "ZodCatch", "ZodNaN", "ZodType", "json", "ZodReadonly", "ZodLazy", "ZodPromise", "ZodFunction", "ZodType", "json", "describe", "meta", "ZodBoolean", "ZodString", "string", "number", "boolean", "_null", "ZodFirstPartyTypeKind", "schemas_exports", "checks_exports", "iso_exports", "en_default", "string", "number", "_null", "object", "ErrorCode", "object", "number", "string", "string", "object", "boolean", "object", "string", "boolean", "object", "number", "string", "_null", "iso_exports", "boolean", "object", "string", "string", "number", "boolean", "object", "safeParse", "error", "task", "safeParse", "jsonrpcNotification", "isPlainObject", "Ajv", "_addFormats", "safeParse", "error", "process", "process", "error", "json", "fs", "path", "os", "process", "error", "json", "error", "error", "serverToken", "requestId", "responsePromise", "url", "error", "WebSocketServer", "MCP_PATH", "WebSocket", "execSync", "requestIdCounter", "pendingRequests", "path", "parse", "channel", "hostname", "meta", "id", "info", "error", "config", "MCP_PATH"] +} diff --git a/build/webmcp.js b/build/webmcp.js new file mode 100644 index 0000000..5bd73a3 --- /dev/null +++ b/build/webmcp.js @@ -0,0 +1,1858 @@ +(() => { + // src/webmcp.js + var WebMCP = class { + constructor(options = {}) { + this.options = { + color: "#007bff", + position: "bottom-right", + size: "30px", + padding: "20px", + inactivityTimeout: 5 * 60 * 1e3, + // 5 minutes in milliseconds + headless: false, + ...options + }; + this._listeners = {}; + this._currentStatus = "disconnected"; + this.isConnected = false; + this.isExpanded = false; + this.socket = null; + this.inactivityTimer = null; + this.availableTools = /* @__PURE__ */ new Map(); + this.availablePrompts = /* @__PURE__ */ new Map(); + this.availableResources = /* @__PURE__ */ new Map(); + this.samplingCallbacks = /* @__PURE__ */ new Map(); + this.currentToken = ""; + this.currentServer = ""; + this.currentChannel = ""; + this.elementId = "webmcp-widget-" + Math.random().toString(36).substr(2, 9); + this.registeredTools = /* @__PURE__ */ new Set(); + this.registeredPrompts = /* @__PURE__ */ new Set(); + this.registeredResources = /* @__PURE__ */ new Set(); + this._reconnectAttempts = 0; + this._maxReconnectAttempts = 3; + this._reconnectDelay = 1e3; + this._lastConnectionToken = null; + this.SESSION_STORAGE_KEY = "webmcp_token"; + this.TOOLS_STORAGE_KEY = "webmcp_tools"; + this.PROMPTS_STORAGE_KEY = "webmcp_prompts"; + this.RESOURCES_STORAGE_KEY = "webmcp_resources"; + this.REGISTER_PATH = "/register"; + this._init(); + } + /** + * Register an event listener + * @public + * @param {string} event - Event name + * @param {Function} callback - Callback function + * @returns {Function} Unsubscribe function + */ + on(event, callback) { + if (!this._listeners[event]) { + this._listeners[event] = []; + } + this._listeners[event].push(callback); + return () => this.off(event, callback); + } + /** + * Remove an event listener + * @public + * @param {string} event - Event name + * @param {Function} callback - Callback function to remove + */ + off(event, callback) { + if (!this._listeners[event]) return; + this._listeners[event] = this._listeners[event].filter((cb) => cb !== callback); + } + /** + * Emit an event to all registered listeners + * @private + * @param {string} event - Event name + * @param {Object} data - Event data + */ + _emit(event, data) { + if (!this._listeners[event]) return; + this._listeners[event].forEach((cb) => { + try { + cb(data); + } catch (e) { + console.error(`Error in ${event} listener:`, e); + } + }); + } + /** + * Get current connection info snapshot + * @public + * @returns {Object} Connection state snapshot + */ + getConnectionInfo() { + return { + isConnected: this.isConnected, + channel: this.currentChannel, + server: this.currentServer, + status: this._currentStatus, + tools: Array.from(this.availableTools.keys()), + prompts: Array.from(this.availablePrompts.keys()), + resources: Array.from(this.availableResources.keys()) + }; + } + _format(s) { + return s.replace(/[.:]/g, "_"); + } + /** + * Initialize the WebMCP widget + * @private + */ + _init() { + if (!this.options.headless) { + if (document.querySelector("[data-webmcp-widget]")) { + console.warn("WebMCP widget already initialized on this page"); + return; + } + this._createWidget(); + this._setupEventListeners(); + } + this._resetInactivityTimer(); + this._checkStoredToken(); + } + /** + * Check for stored connection info in sessionStorage and connect if found + * @private + */ + _checkStoredToken() { + const storedConnectionInfo = sessionStorage.getItem(this.SESSION_STORAGE_KEY); + if (storedConnectionInfo) { + try { + const connectionInfo = JSON.parse(storedConnectionInfo); + if (connectionInfo.token) { + console.log("Found stored connection info, attempting to connect"); + this.currentServer = connectionInfo.server; + this.currentChannel = `/${connectionInfo.channelHost || this._format(window.location.host)}`; + if (connectionInfo.token.includes("{")) { + const tokenData = JSON.parse(connectionInfo.token); + this.currentToken = tokenData.token; + } else { + try { + const jsonStr = atob(connectionInfo.token); + const tokenData = JSON.parse(jsonStr); + this.currentToken = tokenData.token; + } catch (e) { + this.currentToken = connectionInfo.token; + } + } + this._loadStoredItems(); + this.connect(connectionInfo.token); + } + } catch (error) { + console.error("Error parsing stored connection info:", error); + sessionStorage.removeItem(this.SESSION_STORAGE_KEY); + this._clearStoredItems(); + } + } + } + /** + * Save tools, prompts, and resources to session storage + * @private + */ + _saveItemsToStorage() { + try { + const toolsData = {}; + this.availableTools.forEach((tool, name) => { + toolsData[name] = { + name: tool.name, + description: tool.description, + inputSchema: tool.inputSchema + // We don't store the execution function as it can't be serialized + }; + }); + sessionStorage.setItem(this.TOOLS_STORAGE_KEY, JSON.stringify(toolsData)); + const promptsData = {}; + this.availablePrompts.forEach((prompt, name) => { + promptsData[name] = { + name: prompt.name, + description: prompt.description, + arguments: prompt.arguments + // We don't store the execution function as it can't be serialized + }; + }); + sessionStorage.setItem(this.PROMPTS_STORAGE_KEY, JSON.stringify(promptsData)); + const resourcesData = {}; + this.availableResources.forEach((resource, name) => { + resourcesData[name] = { + name: resource.name, + description: resource.description, + uri: resource.uri, + uriTemplate: resource.uriTemplate, + isTemplate: resource.isTemplate, + mimeType: resource.mimeType + // We don't store the provide function as it can't be serialized + }; + }); + sessionStorage.setItem(this.RESOURCES_STORAGE_KEY, JSON.stringify(resourcesData)); + console.log("Saved items to session storage:", { + tools: Object.keys(toolsData).length, + prompts: Object.keys(promptsData).length, + resources: Object.keys(resourcesData).length + }); + } catch (error) { + console.error("Error saving items to session storage:", error); + } + } + /** + * Load tools, prompts, and resources from session storage + * @private + */ + _loadStoredItems() { + try { + const storedTools = sessionStorage.getItem(this.TOOLS_STORAGE_KEY); + if (storedTools) { + const toolsData = JSON.parse(storedTools); + Object.entries(toolsData).forEach(([name, tool]) => { + this.availableTools.set(name, { + ...tool, + execute: function(args) { + console.warn(`Tool ${name} was loaded from storage but has not been re-registered with an execution function`); + return `Tool ${name} needs to be re-registered`; + } + }); + }); + } + const storedPrompts = sessionStorage.getItem(this.PROMPTS_STORAGE_KEY); + if (storedPrompts) { + const promptsData = JSON.parse(storedPrompts); + Object.entries(promptsData).forEach(([name, prompt]) => { + this.availablePrompts.set(name, { + ...prompt, + execute: function(args) { + console.warn(`Prompt ${name} was loaded from storage but has not been re-registered with an execution function`); + return { + messages: [{ + role: "user", + content: { + type: "text", + text: `Prompt ${name} needs to be re-registered` + } + }] + }; + } + }); + }); + } + const storedResources = sessionStorage.getItem(this.RESOURCES_STORAGE_KEY); + if (storedResources) { + const resourcesData = JSON.parse(storedResources); + Object.entries(resourcesData).forEach(([name, resource]) => { + this.availableResources.set(name, { + ...resource, + provide: function(uri) { + console.warn(`Resource ${name} was loaded from storage but has not been re-registered with a provider function`); + return { + contents: [{ + uri, + text: `Resource ${name} needs to be re-registered`, + mimeType: resource.mimeType || "text/plain" + }] + }; + } + }); + }); + } + console.log("Loaded items from session storage:", { + tools: this.availableTools.size, + prompts: this.availablePrompts.size, + resources: this.availableResources.size + }); + this._updateToolsList(); + this._updatePromptsList(); + this._updateResourcesList(); + } catch (error) { + console.error("Error loading items from session storage:", error); + this._clearStoredItems(); + } + } + /** + * Clear all stored items from session storage + * @private + */ + _clearStoredItems() { + sessionStorage.removeItem(this.TOOLS_STORAGE_KEY); + sessionStorage.removeItem(this.PROMPTS_STORAGE_KEY); + sessionStorage.removeItem(this.RESOURCES_STORAGE_KEY); + console.log("Cleared stored items from session storage"); + } + /** + * Create and inject the WebMCP widget into the DOM + * @private + */ + _createWidget() { + const container = document.createElement("div"); + container.id = this.elementId; + container.dataset.webmcpWidget = true; + Object.assign(container.style, { + position: "fixed", + zIndex: "9999", + display: "flex", + flexDirection: "column", + fontFamily: "Arial, sans-serif", + fontSize: "14px", + transition: "all 0.3s ease" + }); + this._setWidgetPosition(container); + const triggerButton = document.createElement("div"); + triggerButton.className = "webmcp-trigger"; + Object.assign(triggerButton.style, { + width: this.options.size, + height: this.options.size, + backgroundColor: this.options.color, + borderRadius: "4px", + cursor: "pointer", + boxShadow: "0 2px 10px rgba(0,0,0,0.2)", + display: "flex", + justifyContent: "center", + alignItems: "center", + alignSelf: "flex-end" + }); + const contentPanel = document.createElement("div"); + contentPanel.className = "webmcp-content"; + Object.assign(contentPanel.style, { + backgroundColor: "#ffffff", + border: "1px solid #e1e1e1", + borderRadius: "5px", + padding: "15px", + marginBottom: "10px", + boxShadow: "0 5px 15px rgba(0,0,0,0.1)", + width: "250px", + display: "none", + overflow: "hidden", + position: "absolute", + bottom: "40px" + }); + const header = document.createElement("div"); + Object.assign(header.style, { + display: "flex", + justifyContent: "space-between", + alignItems: "center", + marginBottom: "15px" + }); + const title = document.createElement("div"); + title.textContent = "WebMCP"; + Object.assign(title.style, { + fontWeight: "bold", + fontSize: "16px" + }); + const closeButton = document.createElement("button"); + closeButton.innerHTML = "×"; + closeButton.className = "webmcp-close"; + Object.assign(closeButton.style, { + background: "none", + border: "none", + cursor: "pointer", + fontSize: "20px", + padding: "0", + lineHeight: "1", + color: "#999" + }); + header.appendChild(title); + header.appendChild(closeButton); + contentPanel.appendChild(header); + this._createConnectionForm(contentPanel); + const statusIndicator = document.createElement("div"); + statusIndicator.className = "webmcp-status"; + statusIndicator.textContent = "Disconnected"; + Object.assign(statusIndicator.style, { + padding: "8px", + borderRadius: "3px", + backgroundColor: "#f8d7da", + color: "#721c24", + textAlign: "center", + marginBottom: "10px", + fontSize: "12px" + }); + contentPanel.appendChild(statusIndicator); + const connectionPanel = document.createElement("div"); + connectionPanel.className = "webmcp-connection-panel"; + contentPanel.appendChild(connectionPanel); + const registeredItemsContainer = document.createElement("div"); + registeredItemsContainer.className = "webmcp-registered-items"; + Object.assign(registeredItemsContainer.style, { + marginTop: "15px", + fontSize: "12px", + display: "none", + maxHeight: "200px", + overflow: "auto", + border: "1px solid #eee", + borderRadius: "4px" + }); + contentPanel.appendChild(registeredItemsContainer); + const toolsList = document.createElement("div"); + toolsList.className = "webmcp-tools-list"; + Object.assign(toolsList.style, { + padding: "10px", + borderBottom: "1px solid #eee" + }); + const toolsHeader = document.createElement("div"); + toolsHeader.textContent = "Registered Tools:"; + Object.assign(toolsHeader.style, { + fontWeight: "bold", + marginBottom: "5px" + }); + const toolsContainer = document.createElement("ul"); + toolsContainer.className = "webmcp-tools-container"; + Object.assign(toolsContainer.style, { + listStyle: "none", + padding: "0", + margin: "0" + }); + toolsList.appendChild(toolsHeader); + toolsList.appendChild(toolsContainer); + registeredItemsContainer.appendChild(toolsList); + const promptsList = document.createElement("div"); + promptsList.className = "webmcp-prompts-list"; + Object.assign(promptsList.style, { + padding: "10px", + borderBottom: "1px solid #eee" + }); + const promptsHeader = document.createElement("div"); + promptsHeader.textContent = "Registered Prompts:"; + Object.assign(promptsHeader.style, { + fontWeight: "bold", + marginBottom: "5px" + }); + const promptsContainer = document.createElement("ul"); + promptsContainer.className = "webmcp-prompts-container"; + Object.assign(promptsContainer.style, { + listStyle: "none", + padding: "0", + margin: "0" + }); + promptsList.appendChild(promptsHeader); + promptsList.appendChild(promptsContainer); + registeredItemsContainer.appendChild(promptsList); + const resourcesList = document.createElement("div"); + resourcesList.className = "webmcp-resources-list"; + Object.assign(resourcesList.style, { + padding: "10px" + }); + const resourcesHeader = document.createElement("div"); + resourcesHeader.textContent = "Registered Resources:"; + Object.assign(resourcesHeader.style, { + fontWeight: "bold", + marginBottom: "5px" + }); + const resourcesContainer = document.createElement("ul"); + resourcesContainer.className = "webmcp-resources-container"; + Object.assign(resourcesContainer.style, { + listStyle: "none", + padding: "0", + margin: "0" + }); + resourcesList.appendChild(resourcesHeader); + resourcesList.appendChild(resourcesContainer); + registeredItemsContainer.appendChild(resourcesList); + container.appendChild(contentPanel); + container.appendChild(triggerButton); + document.body.appendChild(container); + } + /** + * Set widget position based on option + * @private + */ + _setWidgetPosition(container) { + const { position, padding } = this.options; + switch (position) { + case "bottom-right": + Object.assign(container.style, { + bottom: padding, + right: padding, + alignItems: "flex-end" + }); + break; + case "bottom-left": + Object.assign(container.style, { + bottom: padding, + left: padding, + alignItems: "flex-start" + }); + break; + case "top-right": + Object.assign(container.style, { + top: padding, + right: padding, + alignItems: "flex-end" + }); + break; + case "top-left": + Object.assign(container.style, { + top: padding, + left: padding, + alignItems: "flex-start" + }); + break; + default: + Object.assign(container.style, { + bottom: padding, + right: padding, + alignItems: "flex-end" + }); + } + } + /** + * Create the connection form + * @private + */ + _createConnectionForm(container) { + const form = document.createElement("div"); + Object.assign(form.style, { + marginBottom: "8px" + }); + const inputGroup = document.createElement("div"); + Object.assign(inputGroup.style, { + display: "flex", + marginBottom: "8px" + }); + const tokenInput = document.createElement("input"); + tokenInput.type = "text"; + tokenInput.className = "webmcp-token-input"; + tokenInput.placeholder = "Paste connection token"; + Object.assign(tokenInput.style, { + flex: "1", + padding: "8px", + border: "1px solid #ccc", + borderRadius: "4px 0 0 4px", + fontSize: "12px" + }); + const connectButton = document.createElement("button"); + connectButton.className = "webmcp-connect-btn"; + connectButton.textContent = "Connect"; + Object.assign(connectButton.style, { + padding: "8px 12px", + backgroundColor: this.options.color, + color: "white", + border: "none", + borderRadius: "0 4px 4px 0", + cursor: "pointer", + fontSize: "12px" + }); + inputGroup.appendChild(tokenInput); + inputGroup.appendChild(connectButton); + const disconnectButton = document.createElement("button"); + disconnectButton.className = "webmcp-disconnect-btn"; + disconnectButton.textContent = "Disconnect"; + Object.assign(disconnectButton.style, { + padding: "8px 12px", + backgroundColor: "#dc3545", + color: "white", + border: "none", + borderRadius: "4px", + cursor: "pointer", + fontSize: "12px", + width: "100%", + display: "none" + }); + form.appendChild(inputGroup); + form.appendChild(disconnectButton); + container.appendChild(form); + } + /** + * Set up event listeners for the widget + * @private + */ + _setupEventListeners() { + const container = document.getElementById(this.elementId); + if (!container) return; + const trigger = container.querySelector(".webmcp-trigger"); + trigger.addEventListener("click", () => { + this._toggleExpanded(); + }); + const closeBtn = container.querySelector(".webmcp-close"); + closeBtn.addEventListener("click", () => { + this._toggleExpanded(false); + }); + const connectBtn = container.querySelector(".webmcp-connect-btn"); + connectBtn.addEventListener("click", () => { + const tokenInput = container.querySelector(".webmcp-token-input"); + this.connect(tokenInput.value); + }); + const disconnectBtn = container.querySelector(".webmcp-disconnect-btn"); + disconnectBtn.addEventListener("click", () => { + this.disconnect(); + }); + document.addEventListener("mousemove", () => this._resetInactivityTimer()); + document.addEventListener("keypress", () => this._resetInactivityTimer()); + document.addEventListener("click", () => this._resetInactivityTimer()); + document.addEventListener("scroll", () => this._resetInactivityTimer()); + } + /** + * Toggle the expanded state of the widget + * @private + */ + _toggleExpanded(force = null) { + const container = document.getElementById(this.elementId); + if (!container) return; + const contentPanel = container.querySelector(".webmcp-content"); + this.isExpanded = force !== null ? force : !this.isExpanded; + if (this.isExpanded) { + contentPanel.style.display = "block"; + } else { + contentPanel.style.display = "none"; + } + this._resetInactivityTimer(); + } + /** + * Update the status indicator + * @private + */ + _updateStatus(status, message) { + this._currentStatus = status; + this._emit("statusChange", { status, message: message || status }); + const container = document.getElementById(this.elementId); + if (!container) return; + const statusIndicator = container.querySelector(".webmcp-status"); + if (!statusIndicator) return; + statusIndicator.classList.remove("connected", "disconnected", "connecting", "pending-auth"); + statusIndicator.textContent = message || status; + switch (status) { + case "connected": + Object.assign(statusIndicator.style, { + backgroundColor: "#d4edda", + color: "#155724" + }); + break; + case "disconnected": + Object.assign(statusIndicator.style, { + backgroundColor: "#f8d7da", + color: "#721c24" + }); + break; + case "connecting": + Object.assign(statusIndicator.style, { + backgroundColor: "#fff3cd", + color: "#856404" + }); + break; + case "pending-auth": + Object.assign(statusIndicator.style, { + backgroundColor: "#d1ecf1", + color: "#0c5460" + }); + break; + } + } + /** + * Update UI based on connection state + * @private + */ + _updateConnectionUI(isConnected) { + const container = document.getElementById(this.elementId); + if (!container) return; + const tokenInput = container.querySelector(".webmcp-token-input"); + const connectBtn = container.querySelector(".webmcp-connect-btn"); + const disconnectBtn = container.querySelector(".webmcp-disconnect-btn"); + const registeredItemsContainer = container.querySelector(".webmcp-registered-items"); + if (isConnected) { + tokenInput.style.display = "none"; + connectBtn.style.display = "none"; + disconnectBtn.style.display = "block"; + registeredItemsContainer.style.display = "block"; + const trigger = container.querySelector(".webmcp-trigger"); + trigger.innerHTML = "\u2713"; + trigger.style.color = "white"; + trigger.style.fontWeight = "bold"; + } else { + tokenInput.style.display = "block"; + connectBtn.style.display = "block"; + disconnectBtn.style.display = "none"; + registeredItemsContainer.style.display = "none"; + const trigger = container.querySelector(".webmcp-trigger"); + trigger.innerHTML = ""; + } + } + /** + * Update tools list in UI + * @private + */ + _updateToolsList() { + const container = document.getElementById(this.elementId); + if (!container) return; + const toolsContainer = container.querySelector(".webmcp-tools-container"); + if (!toolsContainer) return; + toolsContainer.innerHTML = ""; + if (this.availableTools.size === 0) { + const emptyMessage = document.createElement("li"); + emptyMessage.textContent = "No tools registered"; + emptyMessage.style.fontStyle = "italic"; + emptyMessage.style.color = "#666"; + toolsContainer.appendChild(emptyMessage); + return; + } + this.availableTools.forEach((tool, name) => { + const toolItem = document.createElement("li"); + Object.assign(toolItem.style, { + padding: "5px 0", + borderBottom: "1px solid #eee" + }); + const toolName = document.createElement("strong"); + toolName.textContent = name; + const toolDesc = document.createElement("div"); + toolDesc.textContent = tool.description; + toolDesc.style.fontSize = "10px"; + toolDesc.style.color = "#666"; + toolItem.appendChild(toolName); + toolItem.appendChild(toolDesc); + toolsContainer.appendChild(toolItem); + }); + } + /** + * Update prompts list in UI + * @private + */ + _updatePromptsList() { + const container = document.getElementById(this.elementId); + if (!container) return; + const promptsContainer = container.querySelector(".webmcp-prompts-container"); + if (!promptsContainer) return; + promptsContainer.innerHTML = ""; + if (this.availablePrompts.size === 0) { + const emptyMessage = document.createElement("li"); + emptyMessage.textContent = "No prompts registered"; + emptyMessage.style.fontStyle = "italic"; + emptyMessage.style.color = "#666"; + promptsContainer.appendChild(emptyMessage); + return; + } + this.availablePrompts.forEach((prompt, name) => { + const promptItem = document.createElement("li"); + Object.assign(promptItem.style, { + padding: "5px 0", + borderBottom: "1px solid #eee" + }); + const promptName = document.createElement("strong"); + promptName.textContent = name; + const promptDesc = document.createElement("div"); + promptDesc.textContent = prompt.description; + promptDesc.style.fontSize = "10px"; + promptDesc.style.color = "#666"; + promptItem.appendChild(promptName); + promptItem.appendChild(promptDesc); + promptsContainer.appendChild(promptItem); + }); + } + /** + * Update resources list in UI + * @private + */ + _updateResourcesList() { + const container = document.getElementById(this.elementId); + if (!container) return; + const resourcesContainer = container.querySelector(".webmcp-resources-container"); + if (!resourcesContainer) return; + resourcesContainer.innerHTML = ""; + if (this.availableResources.size === 0) { + const emptyMessage = document.createElement("li"); + emptyMessage.textContent = "No resources registered"; + emptyMessage.style.fontStyle = "italic"; + emptyMessage.style.color = "#666"; + resourcesContainer.appendChild(emptyMessage); + return; + } + this.availableResources.forEach((resource, name) => { + const resourceItem = document.createElement("li"); + Object.assign(resourceItem.style, { + padding: "5px 0", + borderBottom: "1px solid #eee" + }); + const resourceName = document.createElement("strong"); + resourceName.textContent = name; + const resourceDesc = document.createElement("div"); + resourceDesc.textContent = resource.description + (resource.isTemplate ? " (Template)" : ""); + resourceDesc.style.fontSize = "10px"; + resourceDesc.style.color = "#666"; + resourceItem.appendChild(resourceName); + resourceItem.appendChild(resourceDesc); + resourcesContainer.appendChild(resourceItem); + }); + } + /** + * Reset the inactivity timer + * @private + */ + _resetInactivityTimer() { + if (this.inactivityTimer) { + clearTimeout(this.inactivityTimer); + } + this.inactivityTimer = setTimeout(() => { + this._handleInactivity(); + }, this.options.inactivityTimeout); + } + /** + * Handle user inactivity + * @private + */ + _handleInactivity() { + console.log("Inactivity timeout reached, disconnecting"); + if (this.isConnected) { + this.disconnect(); + } + this._toggleExpanded(false); + sessionStorage.removeItem(this.SESSION_STORAGE_KEY); + } + /** + * Connect to the WebSocket server + * @public + * @param {string} connectionToken - The encoded connection token + */ + async connect(connectionToken) { + if (!connectionToken) { + this._updateStatus("disconnected", "Error: No token provided"); + return; + } + this._lastConnectionToken = connectionToken; + this._updateStatus("connecting", "Connecting..."); + try { + if (!this._processConnectionToken(connectionToken)) { + return; + } + const connectionInfo = { + token: connectionToken, + server: this.currentServer, + host: this._format(window.location.host) + }; + const storedConnectionInfo = sessionStorage.getItem(this.SESSION_STORAGE_KEY); + let skipRegistration = false; + if (storedConnectionInfo) { + try { + const connectionInfo2 = JSON.parse(storedConnectionInfo); + if (connectionInfo2.server === this.currentServer && connectionInfo2.host === this._format(window.location.host)) { + skipRegistration = true; + } + } catch (error) { + console.error("Error parsing stored connection info:", error); + } + } + if (!skipRegistration) { + const response = await this._registerWithServer(connectionToken); + if (!response.token) { + this._updateStatus("disconnected", "Registration failed"); + return; + } + connectionInfo.token = response.token; + this.currentToken = response.token; + sessionStorage.setItem(this.SESSION_STORAGE_KEY, JSON.stringify(connectionInfo)); + } + const serverUrl = `${this.currentServer}${this.currentChannel}?token=${this.currentToken}`; + this._updateStatus("connecting", "Connecting to channel..."); + this.socket = new WebSocket(serverUrl); + this._setupSocketListeners(); + this._resetInactivityTimer(); + } catch (error) { + console.error("Connection error:", error); + this._updateStatus("disconnected", `Error: ${error.message}`); + } + } + /** + * Disconnect from WebSocket server + * @public + */ + disconnect() { + if (this.socket) { + this.socket.close(); + this.socket = null; + } + this.isConnected = false; + this._updateStatus("disconnected", "Disconnected"); + this._updateConnectionUI(false); + this.currentToken = ""; + this.currentServer = ""; + this.currentChannel = ""; + sessionStorage.removeItem(this.SESSION_STORAGE_KEY); + this._clearStoredItems(); + } + /** + * Process connection token + * @private + * @param {string} encodedToken - The encoded connection token + * @returns {boolean} - True if processing was successful + */ + _processConnectionToken(encodedToken) { + try { + const jsonStr = atob(encodedToken); + const connectionData = JSON.parse(jsonStr); + const { server, token } = connectionData; + if (!server || !token) { + this._updateStatus("disconnected", "Invalid token"); + return false; + } + this.currentServer = server; + this.currentToken = token; + this.currentChannel = `/${this._format(window.location.host)}`; + return true; + } catch (error) { + this._updateStatus("disconnected", `Unable to parse token`); + return false; + } + } + /** + * Register with server using connection token + * @private + * @param {string} encodedToken - The encoded connection token + * @returns {Promise<{ token: string }>} - Resolves to true if registration was successful + */ + _registerWithServer(encodedToken) { + this._updateStatus("pending-auth", "Registering..."); + const regSocket = new WebSocket(`${this.currentServer}${this.REGISTER_PATH}`); + return new Promise((resolve, reject) => { + regSocket.addEventListener("open", (event) => { + console.log("Registration connection established"); + const jsonStr = atob(encodedToken); + const connectionData = JSON.parse(jsonStr); + connectionData.host = this._format(window.location.host); + regSocket.send(btoa(JSON.stringify(connectionData))); + }); + regSocket.addEventListener("message", (event) => { + try { + const message = JSON.parse(event.data); + if (message.type === "registerSuccess" && message.token) { + console.log(`Registration successful: ${message.message}`); + resolve({ token: message.token }); + } else if (message.type === "error") { + console.error(`Registration failed: ${message.message}`); + this._updateStatus("disconnected", `Registration failed: ${message.message}`); + reject(new Error(message.message)); + } + } catch (error) { + console.error(`Error parsing registration response: ${error.message}`); + this._updateStatus("disconnected", "Error parsing server response"); + reject(error); + } + }); + regSocket.addEventListener("error", (event) => { + console.error("Registration connection error"); + this._updateStatus("disconnected", "Registration connection error"); + sessionStorage.removeItem(this.SESSION_STORAGE_KEY); + reject(new Error("Connection error")); + }); + regSocket.addEventListener("close", (event) => { + console.log(`Registration connection closed: ${event.code} ${event.reason}`); + if (event.code !== 1e3) { + this._updateStatus("disconnected", "Registration failed"); + sessionStorage.removeItem(this.SESSION_STORAGE_KEY); + reject(new Error("Connection closed")); + } + }); + }); + } + /** + * Set up WebSocket event listeners for direct connection + * @private + */ + _setupSocketListeners() { + if (!this.socket) { + console.error("Cannot set up socket listeners: WebSocket not available"); + return; + } + this.socket.addEventListener("open", () => { + this.isConnected = true; + this._reconnectAttempts = 0; + this._updateStatus("connected", `Connected to ${this.currentChannel}`); + this._updateConnectionUI(true); + this._emit("connected", { channel: this.currentChannel, server: this.currentServer }); + console.log("WebMCP connection established"); + this._registerItemsWithServer(); + }); + this.socket.addEventListener("close", (event) => { + this.isConnected = false; + console.log(`Connection closed: ${event.code} ${event.reason}`); + if (event.code === 1e3) { + this._updateStatus("disconnected", "Disconnected"); + this._updateConnectionUI(false); + this._emit("disconnected", { code: event.code, reason: event.reason }); + return; + } + if (this._reconnectAttempts < this._maxReconnectAttempts && this._lastConnectionToken) { + this._reconnectAttempts++; + const delay = this._reconnectDelay * this._reconnectAttempts; + console.log(`Reconnecting (attempt ${this._reconnectAttempts}/${this._maxReconnectAttempts}) in ${delay}ms...`); + this._updateStatus("connecting", `Reconectando (${this._reconnectAttempts}/${this._maxReconnectAttempts})...`); + this._emit("reconnecting", { + attempt: this._reconnectAttempts, + maxAttempts: this._maxReconnectAttempts, + delay + }); + setTimeout(() => { + this.connect(this._lastConnectionToken); + }, delay); + return; + } + this._updateStatus("disconnected", "Disconnected"); + this._updateConnectionUI(false); + this._emit("disconnected", { code: event.code, reason: event.reason }); + this.currentToken = ""; + this.currentServer = ""; + this.currentChannel = ""; + sessionStorage.removeItem(this.SESSION_STORAGE_KEY); + }); + this.socket.addEventListener("error", () => { + if (this._reconnectAttempts > 0) return; + console.error("WebSocket error"); + if (this.isConnected) { + this._updateStatus("disconnected", "Connection error occurred"); + } else { + this._updateStatus("disconnected", "Connection failed"); + } + sessionStorage.removeItem(this.SESSION_STORAGE_KEY); + }); + this.socket.addEventListener("message", (event) => { + try { + const message = JSON.parse(event.data); + this._handleServerMessage(message); + } catch (error) { + console.error(`Error parsing message: ${error.message}`); + } + }); + } + /** + * Handle messages from the server + * @private + * @param {Object} message - The parsed message object + */ + _handleServerMessage(message) { + switch (message.type) { + case "welcome": + console.log(`Server says: ${message.message}`); + this._sendMessage({ + type: "clientInfo", + userAgent: navigator.userAgent, + url: window.location.href, + hostname: window.location.hostname, + language: navigator.language, + screenWidth: window.innerWidth, + screenHeight: window.innerHeight, + timestamp: Date.now() + }); + break; + case "toolRegistered": + console.log(`Tool registered with server: ${message.name}`); + this._emit("toolRegistered", { name: message.name }); + break; + case "promptRegistered": + console.log(`Prompt registered with server: ${message.name}`); + break; + case "resourceRegistered": + console.log(`Resource registered with server: ${message.name}`); + break; + case "callTool": + this._handleToolCall(message); + break; + case "getPrompt": + this._handleGetPrompt(message); + break; + case "readResource": + this._handleReadResource(message); + break; + case "createSamplingMessage": + this._handleCreateSamplingMessage(message); + break; + case "listTools": + this._sendToolsList(message.id); + break; + case "listPrompts": + this._sendPromptsList(message.id); + break; + case "listResources": + this._sendResourcesList(message.id); + break; + case "ping": + this._sendMessage({ + type: "pong", + id: message.id, + timestamp: Date.now() + }); + break; + case "createTool": + this._handleCreateTool(message); + break; + case "removeTool": + if (message.name && this.availableTools.has(message.name)) { + this.availableTools.delete(message.name); + this.registeredTools.delete(message.name); + this._saveItemsToStorage(); + this._updateToolsList(); + this._emit("toolRemoved", { name: message.name }); + console.log(`Tool removed by server: ${message.name}`); + } + break; + case "removeAllTools": + this.availableTools.clear(); + this.registeredTools.clear(); + this._saveItemsToStorage(); + this._updateToolsList(); + this._emit("toolRemoved", { name: "*" }); + console.log("All tools removed by server"); + break; + case "getClientInfo": + this._sendMessage({ + id: message.id, + type: "clientInfoResponse", + userAgent: navigator.userAgent, + url: window.location.href, + hostname: window.location.hostname, + language: navigator.language, + screenWidth: window.innerWidth, + screenHeight: window.innerHeight, + timestamp: Date.now() + }); + break; + case "clipboardCopy": + if (message.text && navigator.clipboard) { + navigator.clipboard.writeText(message.text).then(() => { + console.log("Token copiado al portapapeles"); + }).catch((err) => { + console.error("Error copiando al portapapeles:", err); + }); + } + break; + case "error": + console.error(`Server error: ${message.message}`); + this._emit("error", { message: message.message }); + break; + default: + console.warn(`Unknown message type: ${message.type}`); + } + } + /** + * Handle createTool request from server (via built-in agregar-tool) + * @private + * @param {Object} message - The parsed message object + */ + _handleCreateTool(message) { + const { id, name, description, code, parametros } = message; + try { + let props = {}; + if (parametros) props = JSON.parse(parametros); + const schema = { type: "object", properties: props }; + const fn = new Function("args", code); + this.registerTool(name, description, schema, fn); + this._sendMessage({ + id, + type: "toolResponse", + result: { content: [{ type: "text", text: `Herramienta "${name}" registrada exitosamente` }] } + }); + this._emit("toolCreated", { name }); + console.log(`Tool created by agent: ${name}`); + } catch (e) { + this._sendMessage({ + id, + type: "toolResponse", + error: `Error creando herramienta: ${e.message}` + }); + } + } + /** + * Handle tool call from server + * @private + * @param {Object} message - The parsed message object + */ + _handleToolCall(message) { + const { id, tool, arguments: args } = message; + console.log(`Tool call: ${tool} with args:`, args); + if (!this.availableTools.has(tool)) { + this._sendMessage({ + id, + type: "toolResponse", + error: `Tool not found: ${tool}` + }); + return; + } + try { + const toolObj = this.availableTools.get(tool); + const wrapResult = (raw) => { + if (raw && raw.content && Array.isArray(raw.content)) return raw; + const text = typeof raw === "string" ? raw : JSON.stringify(raw); + return { content: [{ type: "text", text }] }; + }; + const result = toolObj.execute(args); + if (result instanceof Promise) { + result.then((resolvedResult) => { + this._sendMessage({ + id, + type: "toolResponse", + result: wrapResult(resolvedResult) + }); + }).catch((error) => { + this._sendMessage({ + id, + type: "toolResponse", + error: error.message || "Tool execution error" + }); + }); + } else { + this._sendMessage({ + id, + type: "toolResponse", + result: wrapResult(result) + }); + } + console.log(`Tool response sent for ${tool}`); + } catch (error) { + this._sendMessage({ + id, + type: "toolResponse", + error: error.message || "Tool execution error" + }); + console.error(`Tool execution error:`, error); + } + } + /** + * Handle prompt request from server + * @private + * @param {Object} message - The parsed message object + */ + _handleGetPrompt(message) { + const { id, name, arguments: args } = message; + console.log(`Prompt request: ${name} with args:`, args); + if (!this.availablePrompts.has(name)) { + this._sendMessage({ + id, + type: "promptResponse", + error: `Prompt not found: ${name}` + }); + return; + } + try { + const promptObj = this.availablePrompts.get(name); + const result = promptObj.execute(args); + if (result instanceof Promise) { + result.then((resolvedResult) => { + this._sendMessage({ + id, + type: "promptResponse", + result: resolvedResult + }); + }).catch((error) => { + this._sendMessage({ + id, + type: "promptResponse", + error: error.message || "Prompt execution error" + }); + }); + } else { + this._sendMessage({ + id, + type: "promptResponse", + result + }); + } + console.log(`Prompt response sent for ${name}`); + } catch (error) { + this._sendMessage({ + id, + type: "promptResponse", + error: error.message || "Prompt execution error" + }); + console.error(`Prompt execution error:`, error); + } + } + /** + * Handle resource request from server + * @private + * @param {Object} message - The parsed message object + */ + _handleReadResource(message) { + const { id, uri } = message; + console.log(`Resource request: ${uri}`); + let resourceObj = null; + for (const resource of this.availableResources.values()) { + if (!resource.isTemplate && resource.uri === uri) { + resourceObj = resource; + break; + } + } + if (!resourceObj) { + for (const resource of this.availableResources.values()) { + if (resource.isTemplate) { + const templatePrefix = resource.uriTemplate.split("{")[0]; + if (uri.startsWith(templatePrefix)) { + resourceObj = resource; + break; + } + } + } + } + if (!resourceObj) { + this._sendMessage({ + id, + type: "resourceResponse", + error: `No resource handler found for URI: ${uri}` + }); + return; + } + try { + const result = resourceObj.provide(uri); + if (result instanceof Promise) { + result.then((resolvedResult) => { + this._sendMessage({ + id, + type: "resourceResponse", + result: resolvedResult + }); + }).catch((error) => { + this._sendMessage({ + id, + type: "resourceResponse", + error: error.message || "Resource read error" + }); + }); + } else { + this._sendMessage({ + id, + type: "resourceResponse", + result + }); + } + console.log(`Resource response sent for ${uri}`); + } catch (error) { + this._sendMessage({ + id, + type: "resourceResponse", + error: error.message || "Resource read error" + }); + console.error(`Resource read error:`, error); + } + } + /** + * Send available tools list + * @private + * @param {string} requestId - The request ID to respond to + */ + _sendToolsList(requestId) { + const toolsList = Array.from(this.availableTools.values()).map((tool) => ({ + name: tool.name, + description: tool.description, + inputSchema: tool.inputSchema + })); + this._sendMessage({ + id: requestId, + type: "listToolsResponse", + tools: toolsList + }); + console.log(`Sent tools list: ${toolsList.length} tools`); + } + /** + * Send available prompts list + * @private + * @param {string} requestId - The request ID to respond to + */ + _sendPromptsList(requestId) { + const promptsList = Array.from(this.availablePrompts.values()).map((prompt) => ({ + name: prompt.name, + description: prompt.description, + arguments: prompt.arguments + })); + this._sendMessage({ + id: requestId, + type: "listPromptsResponse", + prompts: promptsList + }); + console.log(`Sent prompts list: ${promptsList.length} prompts`); + } + /** + * Send available resources list + * @private + * @param {string} requestId - The request ID to respond to + */ + _sendResourcesList(requestId) { + const resources = []; + const resourceTemplates = []; + this.availableResources.forEach((resource) => { + if (resource.isTemplate) { + resourceTemplates.push({ + name: resource.name, + description: resource.description, + uriTemplate: resource.uriTemplate, + mimeType: resource.mimeType + }); + } else { + resources.push({ + name: resource.name, + description: resource.description, + uri: resource.uri, + mimeType: resource.mimeType + }); + } + }); + this._sendMessage({ + id: requestId, + type: "listResourcesResponse", + resources, + resourceTemplates + }); + console.log(`Sent resources list: ${resources.length} resources, ${resourceTemplates.length} templates`); + } + /** + * Send a message to the server via direct WebSocket + * @private + * @param {Object} message - The message object to send + */ + _sendMessage(message) { + if (!this.isConnected || !this.socket) { + console.error("Cannot send message: not connected"); + return; + } + try { + this.socket.send(JSON.stringify(message)); + return Promise.resolve(); + } catch (error) { + console.error(`Error sending message: ${error.message}`); + return Promise.reject(error); + } + } + /** + * Register all items with server that were registered while disconnected + * @private + */ + _registerItemsWithServer() { + if (!this.isConnected) return; + this.registeredTools = /* @__PURE__ */ new Set(); + this.registeredPrompts = /* @__PURE__ */ new Set(); + this.registeredResources = /* @__PURE__ */ new Set(); + this.availableTools.forEach((tool, name) => { + this._sendMessage({ + type: "registerTool", + name, + description: tool.description, + inputSchema: tool.inputSchema + }); + this.registeredTools.add(name); + console.log(`Registering tool with server: ${name}`); + }); + this.availablePrompts.forEach((prompt, name) => { + this._sendMessage({ + type: "registerPrompt", + name, + description: prompt.description, + arguments: prompt.arguments + }); + this.registeredPrompts.add(name); + console.log(`Registering prompt with server: ${name}`); + }); + this.availableResources.forEach((resource, name) => { + this._sendMessage({ + type: "registerResource", + name, + description: resource.description, + uri: resource.uri, + uriTemplate: resource.uriTemplate, + isTemplate: resource.isTemplate, + mimeType: resource.mimeType + }); + this.registeredResources.add(name); + console.log(`Registering resource with server: ${name}`); + }); + } + /** + * Register a tool + * @public + * @param {string} name - The name of the tool + * @param {string} description - The description of the tool + * @param {Object} schema - The schema for the tool's input + * @param {Function} executeFn - The function to execute when the tool is called + */ + registerTool(name, description, schema, executeFn) { + if (!name) { + console.error("Tool name is required"); + return; + } + this.availableTools.set(name, { + name, + description: description || `Tool: ${name}`, + execute: executeFn || function(args) { + return `Default implementation of ${name} with args: ${JSON.stringify(args)}`; + }, + inputSchema: schema || { + type: "object", + properties: {} + } + }); + if (this.isConnected) { + this._sendMessage({ + type: "registerTool", + name, + description: description || `Tool: ${name}`, + inputSchema: schema || { + type: "object", + properties: {} + } + }); + this.registeredTools.add(name); + } + this._saveItemsToStorage(); + this._updateToolsList(); + console.log(`Tool registered: ${name}`); + } + /** + * Unregister a tool + * @public + * @param {string} name - The name of the tool to unregister + */ + unregisterTool(name) { + if (!name) { + console.error("Tool name is required"); + return; + } + if (!this.availableTools.has(name)) { + console.warn(`Tool not found: ${name}`); + return; + } + this.availableTools.delete(name); + if (this.isConnected) { + this._sendMessage({ + type: "unregisterTool", + name + }); + } + this.registeredTools.delete(name); + this._saveItemsToStorage(); + this._updateToolsList(); + console.log(`Tool unregistered: ${name}`); + } + /** + * Unregister all tools at once (single notification) + * @public + */ + unregisterAllTools() { + if (this.availableTools.size === 0) return; + this.availableTools.clear(); + this.registeredTools.clear(); + if (this.isConnected) { + this._sendMessage({ type: "unregisterAllTools" }); + } + this._saveItemsToStorage(); + this._updateToolsList(); + console.log("All tools unregistered"); + } + /** + * Register a prompt + * @public + * @param {string} name - The name of the prompt + * @param {string} description - The description of the prompt + * @param {Array} promptArgs - The arguments for the prompt + * @param {Function} executeFn - The function to execute when the prompt is called + */ + registerPrompt(name, description, promptArgs, executeFn) { + if (!name) { + console.error("Prompt name is required"); + return; + } + this.availablePrompts.set(name, { + name, + description: description || `Prompt: ${name}`, + execute: executeFn || function(args) { + return { + messages: [{ + role: "user", + content: { + type: "text", + text: `Default implementation of prompt ${name} with args: ${JSON.stringify(args)}` + } + }] + }; + }, + arguments: promptArgs || [] + }); + if (this.isConnected) { + this._sendMessage({ + type: "registerPrompt", + name, + description: description || `Prompt: ${name}`, + arguments: promptArgs || [] + }); + this.registeredPrompts.add(name); + } + this._saveItemsToStorage(); + this._updatePromptsList(); + console.log(`Prompt registered: ${name}`); + } + /** + * Unregister a prompt + * @public + * @param {string} name - The name of the prompt to unregister + */ + unregisterPrompt(name) { + if (!name) { + console.error("Prompt name is required"); + return; + } + if (!this.availablePrompts.has(name)) { + console.warn(`Prompt not found: ${name}`); + return; + } + this.availablePrompts.delete(name); + if (this.isConnected) { + this._sendMessage({ + type: "unregisterPrompt", + name + }); + } + this.registeredPrompts.delete(name); + this._saveItemsToStorage(); + this._updatePromptsList(); + console.log(`Prompt unregistered: ${name}`); + } + /** + * Register a resource + * @public + * @param {string} name - The name of the resource + * @param {string} description - The description of the resource + * @param {Object} options - The resource options including uri, uriTemplate, and mimeType + * @param {Function} provideFn - The function to execute when the resource is requested + */ + registerResource(name, description, options, provideFn) { + if (!name) { + console.error("Resource name is required"); + return; + } + if (!options.uri && !options.uriTemplate) { + console.error("Either uri or uriTemplate is required for a resource"); + return; + } + const isTemplate = !!options.uriTemplate; + this.availableResources.set(name, { + name, + description: description || `Resource: ${name}`, + uri: options.uri, + uriTemplate: options.uriTemplate, + isTemplate, + mimeType: options.mimeType, + provide: provideFn || function(uri) { + return { + contents: [{ + uri, + text: `Default implementation of resource ${name} for URI: ${uri}`, + mimeType: options.mimeType || "text/plain" + }] + }; + } + }); + if (this.isConnected) { + this._sendMessage({ + type: "registerResource", + name, + description: description || `Resource: ${name}`, + uri: options.uri, + uriTemplate: options.uriTemplate, + isTemplate, + mimeType: options.mimeType + }); + this.registeredResources.add(name); + } + this._saveItemsToStorage(); + this._updateResourcesList(); + console.log(`Resource registered: ${name}`); + } + /** + * Unregister a resource + * @public + * @param {string} name - The name of the resource to unregister + */ + unregisterResource(name) { + if (!name) { + console.error("Resource name is required"); + return; + } + if (!this.availableResources.has(name)) { + console.warn(`Resource not found: ${name}`); + return; + } + this.availableResources.delete(name); + if (this.isConnected) { + this._sendMessage({ + type: "unregisterResource", + name + }); + } + this.registeredResources.delete(name); + this._saveItemsToStorage(); + this._updateResourcesList(); + console.log(`Resource unregistered: ${name}`); + } + /** + * Handle sampling message creation request + * @private + * @param {Object} message - The parsed message object + */ + _handleCreateSamplingMessage(message) { + const { + id, + messages, + systemPrompt, + includeContext, + temperature, + maxTokens, + stopSequences, + metadata, + modelPreferences + } = message; + console.log(`Sampling request received with ${messages?.length || 0} messages`); + const modal = document.createElement("div"); + Object.assign(modal.style, { + position: "fixed", + top: "0", + left: "0", + width: "100%", + height: "100%", + backgroundColor: "rgba(0, 0, 0, 0.5)", + display: "flex", + justifyContent: "center", + alignItems: "center", + zIndex: "10000" + }); + const modalContent = document.createElement("div"); + Object.assign(modalContent.style, { + backgroundColor: "white", + padding: "20px", + borderRadius: "5px", + maxWidth: "500px", + width: "90%", + maxHeight: "80%", + overflow: "auto" + }); + const header = document.createElement("h3"); + header.textContent = "Sampling Request"; + Object.assign(header.style, { + margin: "0 0 15px 0", + padding: "0 0 10px 0", + borderBottom: "1px solid #ddd" + }); + const content = document.createElement("div"); + Object.assign(content.style, { + marginBottom: "15px", + maxHeight: "300px", + overflow: "auto", + border: "1px solid #ddd", + padding: "10px", + backgroundColor: "#f9f9f9" + }); + if (messages && messages.length > 0) { + messages.forEach((msg) => { + const msgDiv = document.createElement("div"); + Object.assign(msgDiv.style, { + marginBottom: "10px", + padding: "5px", + borderRadius: "3px", + backgroundColor: msg.role === "user" ? "#e1f5fe" : "#f1f8e9" + }); + const roleSpan = document.createElement("strong"); + roleSpan.textContent = msg.role === "user" ? "User: " : "Assistant: "; + const contentSpan = document.createElement("span"); + if (msg.content.type === "text") { + contentSpan.textContent = msg.content.text; + } else if (msg.content.type === "image") { + contentSpan.textContent = "[Image data]"; + } + msgDiv.appendChild(roleSpan); + msgDiv.appendChild(contentSpan); + content.appendChild(msgDiv); + }); + } else { + content.textContent = "No messages provided in sampling request"; + } + if (systemPrompt) { + const sysPromptDiv = document.createElement("div"); + Object.assign(sysPromptDiv.style, { + marginBottom: "10px", + padding: "5px", + backgroundColor: "#fff8e1" + }); + const sysPromptLabel = document.createElement("strong"); + sysPromptLabel.textContent = "System Prompt: "; + const sysPromptContent = document.createElement("span"); + sysPromptContent.textContent = systemPrompt; + sysPromptDiv.appendChild(sysPromptLabel); + sysPromptDiv.appendChild(sysPromptContent); + content.appendChild(sysPromptDiv); + } + const responseLabel = document.createElement("label"); + responseLabel.textContent = "Assistant Response:"; + Object.assign(responseLabel.style, { + display: "block", + marginBottom: "5px", + fontWeight: "bold" + }); + const responseInput = document.createElement("textarea"); + Object.assign(responseInput.style, { + width: "100%", + minHeight: "100px", + padding: "10px", + marginBottom: "15px", + boxSizing: "border-box" + }); + const buttonContainer = document.createElement("div"); + Object.assign(buttonContainer.style, { + display: "flex", + justifyContent: "space-between" + }); + const submitButton = document.createElement("button"); + submitButton.textContent = "Submit Response"; + Object.assign(submitButton.style, { + padding: "8px 15px", + backgroundColor: "#4CAF50", + color: "white", + border: "none", + borderRadius: "4px", + cursor: "pointer" + }); + const cancelButton = document.createElement("button"); + cancelButton.textContent = "Cancel"; + Object.assign(cancelButton.style, { + padding: "8px 15px", + backgroundColor: "#f44336", + color: "white", + border: "none", + borderRadius: "4px", + cursor: "pointer" + }); + buttonContainer.appendChild(cancelButton); + buttonContainer.appendChild(submitButton); + modalContent.appendChild(header); + modalContent.appendChild(content); + modalContent.appendChild(responseLabel); + modalContent.appendChild(responseInput); + modalContent.appendChild(buttonContainer); + modal.appendChild(modalContent); + document.body.appendChild(modal); + responseInput.focus(); + submitButton.addEventListener("click", () => { + const responseText = responseInput.value.trim(); + if (responseText) { + this._sendMessage({ + id, + type: "samplingResponse", + result: { + model: "web-user-input", + role: "assistant", + content: { + type: "text", + text: responseText + } + } + }); + document.body.removeChild(modal); + } else { + alert("Please enter a response"); + } + }); + cancelButton.addEventListener("click", () => { + this._sendMessage({ + id, + type: "samplingResponse", + error: "User cancelled sampling request" + }); + document.body.removeChild(modal); + }); + } + }; + if (typeof module !== "undefined" && typeof module.exports !== "undefined") { + module.exports = WebMCP; + } +})(); +//# sourceMappingURL=webmcp.js.map diff --git a/build/webmcp.js.map b/build/webmcp.js.map new file mode 100644 index 0000000..86ecf73 --- /dev/null +++ b/build/webmcp.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../src/webmcp.js"], + "sourcesContent": ["/**\n * WebMCP - Snippet to add MCP functionality to any website\n *\n * Shows as a small blue square in bottom right corner\n * On click, expands to allow connection with token\n * Auto-disconnects after 5 minutes of inactivity\n */\n\nclass WebMCP {\n constructor(options = {}) {\n // Options with defaults\n this.options = {\n color: '#007bff',\n position: 'bottom-right',\n size: '30px',\n padding: '20px',\n inactivityTimeout: 5 * 60 * 1000, // 5 minutes in milliseconds\n headless: false,\n ...options\n };\n\n // Event emitter\n this._listeners = {};\n this._currentStatus = 'disconnected';\n\n // State variables\n this.isConnected = false;\n this.isExpanded = false;\n this.socket = null;\n this.inactivityTimer = null;\n this.availableTools = new Map();\n this.availablePrompts = new Map();\n this.availableResources = new Map();\n this.samplingCallbacks = new Map(); // For storing sampling callbacks\n this.currentToken = '';\n this.currentServer = '';\n this.currentChannel = '';\n this.elementId = 'webmcp-widget-' + Math.random().toString(36).substr(2, 9);\n this.registeredTools = new Set();\n this.registeredPrompts = new Set();\n this.registeredResources = new Set();\n this._reconnectAttempts = 0;\n this._maxReconnectAttempts = 3;\n this._reconnectDelay = 1000;\n this._lastConnectionToken = null;\n\n // Storage keys for sessionStorage\n this.SESSION_STORAGE_KEY = 'webmcp_token';\n this.TOOLS_STORAGE_KEY = 'webmcp_tools';\n this.PROMPTS_STORAGE_KEY = 'webmcp_prompts';\n this.RESOURCES_STORAGE_KEY = 'webmcp_resources';\n\n // Constants\n this.REGISTER_PATH = '/register';\n\n // Initialize\n this._init();\n }\n\n /**\n * Register an event listener\n * @public\n * @param {string} event - Event name\n * @param {Function} callback - Callback function\n * @returns {Function} Unsubscribe function\n */\n on(event, callback) {\n if (!this._listeners[event]) {\n this._listeners[event] = [];\n }\n this._listeners[event].push(callback);\n return () => this.off(event, callback);\n }\n\n /**\n * Remove an event listener\n * @public\n * @param {string} event - Event name\n * @param {Function} callback - Callback function to remove\n */\n off(event, callback) {\n if (!this._listeners[event]) return;\n this._listeners[event] = this._listeners[event].filter(cb => cb !== callback);\n }\n\n /**\n * Emit an event to all registered listeners\n * @private\n * @param {string} event - Event name\n * @param {Object} data - Event data\n */\n _emit(event, data) {\n if (!this._listeners[event]) return;\n this._listeners[event].forEach(cb => {\n try { cb(data); } catch (e) { console.error(`Error in ${event} listener:`, e); }\n });\n }\n\n /**\n * Get current connection info snapshot\n * @public\n * @returns {Object} Connection state snapshot\n */\n getConnectionInfo() {\n return {\n isConnected: this.isConnected,\n channel: this.currentChannel,\n server: this.currentServer,\n status: this._currentStatus,\n tools: Array.from(this.availableTools.keys()),\n prompts: Array.from(this.availablePrompts.keys()),\n resources: Array.from(this.availableResources.keys()),\n };\n }\n\n _format(s) {\n return s.replace(/[.:]/g, '_');\n }\n\n /**\n * Initialize the WebMCP widget\n * @private\n */\n _init() {\n if (!this.options.headless) {\n // Check if already initialized on this page\n if (document.querySelector('[data-webmcp-widget]')) {\n console.warn('WebMCP widget already initialized on this page');\n return;\n }\n\n // Create and inject the widget\n this._createWidget();\n\n // Set up event listeners\n this._setupEventListeners();\n }\n\n // Start inactivity timer\n this._resetInactivityTimer();\n\n // Check for stored token and connect if available\n this._checkStoredToken();\n }\n\n /**\n * Check for stored connection info in sessionStorage and connect if found\n * @private\n */\n _checkStoredToken() {\n const storedConnectionInfo = sessionStorage.getItem(this.SESSION_STORAGE_KEY);\n\n if (storedConnectionInfo) {\n try {\n const connectionInfo = JSON.parse(storedConnectionInfo);\n if (connectionInfo.token) {\n console.log('Found stored connection info, attempting to connect');\n\n // Set the connection properties directly\n this.currentServer = connectionInfo.server;\n this.currentChannel = `/${connectionInfo.channelHost || this._format(window.location.host)}`;\n\n // Set the current token from connection info\n if (connectionInfo.token.includes('{')) {\n // It's already parsed JSON\n const tokenData = JSON.parse(connectionInfo.token);\n this.currentToken = tokenData.token;\n } else {\n // It's a base64 encoded string\n try {\n const jsonStr = atob(connectionInfo.token);\n const tokenData = JSON.parse(jsonStr);\n this.currentToken = tokenData.token;\n } catch (e) {\n this.currentToken = connectionInfo.token;\n }\n }\n\n // Load stored items before connecting\n this._loadStoredItems();\n\n // Connect using the stored token\n this.connect(connectionInfo.token);\n }\n } catch (error) {\n console.error('Error parsing stored connection info:', error);\n sessionStorage.removeItem(this.SESSION_STORAGE_KEY);\n this._clearStoredItems();\n }\n }\n }\n\n /**\n * Save tools, prompts, and resources to session storage\n * @private\n */\n _saveItemsToStorage() {\n try {\n // Save tools\n const toolsData = {};\n this.availableTools.forEach((tool, name) => {\n toolsData[name] = {\n name: tool.name,\n description: tool.description,\n inputSchema: tool.inputSchema,\n // We don't store the execution function as it can't be serialized\n };\n });\n sessionStorage.setItem(this.TOOLS_STORAGE_KEY, JSON.stringify(toolsData));\n\n // Save prompts\n const promptsData = {};\n this.availablePrompts.forEach((prompt, name) => {\n promptsData[name] = {\n name: prompt.name,\n description: prompt.description,\n arguments: prompt.arguments,\n // We don't store the execution function as it can't be serialized\n };\n });\n sessionStorage.setItem(this.PROMPTS_STORAGE_KEY, JSON.stringify(promptsData));\n\n // Save resources\n const resourcesData = {};\n this.availableResources.forEach((resource, name) => {\n resourcesData[name] = {\n name: resource.name,\n description: resource.description,\n uri: resource.uri,\n uriTemplate: resource.uriTemplate,\n isTemplate: resource.isTemplate,\n mimeType: resource.mimeType,\n // We don't store the provide function as it can't be serialized\n };\n });\n sessionStorage.setItem(this.RESOURCES_STORAGE_KEY, JSON.stringify(resourcesData));\n\n console.log('Saved items to session storage:', {\n tools: Object.keys(toolsData).length,\n prompts: Object.keys(promptsData).length,\n resources: Object.keys(resourcesData).length\n });\n } catch (error) {\n console.error('Error saving items to session storage:', error);\n }\n }\n\n /**\n * Load tools, prompts, and resources from session storage\n * @private\n */\n _loadStoredItems() {\n try {\n // Load tools\n const storedTools = sessionStorage.getItem(this.TOOLS_STORAGE_KEY);\n if (storedTools) {\n const toolsData = JSON.parse(storedTools);\n Object.entries(toolsData).forEach(([name, tool]) => {\n // Add to the available tools with placeholder execute function\n this.availableTools.set(name, {\n ...tool,\n execute: function (args) {\n console.warn(`Tool ${name} was loaded from storage but has not been re-registered with an execution function`);\n return `Tool ${name} needs to be re-registered`;\n }\n });\n });\n }\n\n // Load prompts\n const storedPrompts = sessionStorage.getItem(this.PROMPTS_STORAGE_KEY);\n if (storedPrompts) {\n const promptsData = JSON.parse(storedPrompts);\n Object.entries(promptsData).forEach(([name, prompt]) => {\n // Add to the available prompts with placeholder execute function\n this.availablePrompts.set(name, {\n ...prompt,\n execute: function (args) {\n console.warn(`Prompt ${name} was loaded from storage but has not been re-registered with an execution function`);\n return {\n messages: [{\n role: \"user\",\n content: {\n type: \"text\",\n text: `Prompt ${name} needs to be re-registered`\n }\n }]\n };\n }\n });\n });\n }\n\n // Load resources\n const storedResources = sessionStorage.getItem(this.RESOURCES_STORAGE_KEY);\n if (storedResources) {\n const resourcesData = JSON.parse(storedResources);\n Object.entries(resourcesData).forEach(([name, resource]) => {\n // Add to the available resources with placeholder provide function\n this.availableResources.set(name, {\n ...resource,\n provide: function (uri) {\n console.warn(`Resource ${name} was loaded from storage but has not been re-registered with a provider function`);\n return {\n contents: [{\n uri: uri,\n text: `Resource ${name} needs to be re-registered`,\n mimeType: resource.mimeType || \"text/plain\"\n }]\n };\n }\n });\n });\n }\n\n console.log('Loaded items from session storage:', {\n tools: this.availableTools.size,\n prompts: this.availablePrompts.size,\n resources: this.availableResources.size\n });\n\n // Update the UI\n this._updateToolsList();\n this._updatePromptsList();\n this._updateResourcesList();\n\n } catch (error) {\n console.error('Error loading items from session storage:', error);\n this._clearStoredItems();\n }\n }\n\n /**\n * Clear all stored items from session storage\n * @private\n */\n _clearStoredItems() {\n sessionStorage.removeItem(this.TOOLS_STORAGE_KEY);\n sessionStorage.removeItem(this.PROMPTS_STORAGE_KEY);\n sessionStorage.removeItem(this.RESOURCES_STORAGE_KEY);\n console.log('Cleared stored items from session storage');\n }\n\n /**\n * Create and inject the WebMCP widget into the DOM\n * @private\n */\n _createWidget() {\n // Create main container\n const container = document.createElement('div');\n container.id = this.elementId;\n container.dataset.webmcpWidget = true;\n\n // Apply styles\n Object.assign(container.style, {\n position: 'fixed',\n zIndex: '9999',\n display: 'flex',\n flexDirection: 'column',\n fontFamily: 'Arial, sans-serif',\n fontSize: '14px',\n transition: 'all 0.3s ease'\n });\n\n // Set position based on option\n this._setWidgetPosition(container);\n\n // Create trigger button (blue square)\n const triggerButton = document.createElement('div');\n triggerButton.className = 'webmcp-trigger';\n Object.assign(triggerButton.style, {\n width: this.options.size,\n height: this.options.size,\n backgroundColor: this.options.color,\n borderRadius: '4px',\n cursor: 'pointer',\n boxShadow: '0 2px 10px rgba(0,0,0,0.2)',\n display: 'flex',\n justifyContent: 'center',\n alignItems: 'center',\n alignSelf: 'flex-end'\n });\n\n // Create content panel (initially hidden) - positioned above the trigger\n const contentPanel = document.createElement('div');\n contentPanel.className = 'webmcp-content';\n Object.assign(contentPanel.style, {\n backgroundColor: '#ffffff',\n border: '1px solid #e1e1e1',\n borderRadius: '5px',\n padding: '15px',\n marginBottom: '10px',\n boxShadow: '0 5px 15px rgba(0,0,0,0.1)',\n width: '250px',\n display: 'none',\n overflow: 'hidden',\n position: 'absolute',\n bottom: '40px'\n });\n\n // Add header with title and close button\n const header = document.createElement('div');\n Object.assign(header.style, {\n display: 'flex',\n justifyContent: 'space-between',\n alignItems: 'center',\n marginBottom: '15px'\n });\n\n const title = document.createElement('div');\n title.textContent = 'WebMCP';\n Object.assign(title.style, {\n fontWeight: 'bold',\n fontSize: '16px'\n });\n\n const closeButton = document.createElement('button');\n closeButton.innerHTML = '×'; // \u00D7 symbol\n closeButton.className = 'webmcp-close';\n Object.assign(closeButton.style, {\n background: 'none',\n border: 'none',\n cursor: 'pointer',\n fontSize: '20px',\n padding: '0',\n lineHeight: '1',\n color: '#999'\n });\n\n header.appendChild(title);\n header.appendChild(closeButton);\n contentPanel.appendChild(header);\n\n // Add connection form\n this._createConnectionForm(contentPanel);\n\n // Add status indicator\n const statusIndicator = document.createElement('div');\n statusIndicator.className = 'webmcp-status';\n statusIndicator.textContent = 'Disconnected';\n Object.assign(statusIndicator.style, {\n padding: '8px',\n borderRadius: '3px',\n backgroundColor: '#f8d7da',\n color: '#721c24',\n textAlign: 'center',\n marginBottom: '10px',\n fontSize: '12px'\n });\n contentPanel.appendChild(statusIndicator);\n\n // Add connection panel\n const connectionPanel = document.createElement('div');\n connectionPanel.className = 'webmcp-connection-panel';\n contentPanel.appendChild(connectionPanel);\n\n // Create a single container for all registered items\n const registeredItemsContainer = document.createElement('div');\n registeredItemsContainer.className = 'webmcp-registered-items';\n Object.assign(registeredItemsContainer.style, {\n marginTop: '15px',\n fontSize: '12px',\n display: 'none',\n maxHeight: '200px',\n overflow: 'auto',\n border: '1px solid #eee',\n borderRadius: '4px'\n });\n contentPanel.appendChild(registeredItemsContainer);\n\n // Add features lists (initially empty)\n // Tools list\n const toolsList = document.createElement('div');\n toolsList.className = 'webmcp-tools-list';\n Object.assign(toolsList.style, {\n padding: '10px',\n borderBottom: '1px solid #eee'\n });\n\n const toolsHeader = document.createElement('div');\n toolsHeader.textContent = 'Registered Tools:';\n Object.assign(toolsHeader.style, {\n fontWeight: 'bold',\n marginBottom: '5px'\n });\n\n const toolsContainer = document.createElement('ul');\n toolsContainer.className = 'webmcp-tools-container';\n Object.assign(toolsContainer.style, {\n listStyle: 'none',\n padding: '0',\n margin: '0'\n });\n\n toolsList.appendChild(toolsHeader);\n toolsList.appendChild(toolsContainer);\n registeredItemsContainer.appendChild(toolsList);\n\n // Prompts list\n const promptsList = document.createElement('div');\n promptsList.className = 'webmcp-prompts-list';\n Object.assign(promptsList.style, {\n padding: '10px',\n borderBottom: '1px solid #eee'\n });\n\n const promptsHeader = document.createElement('div');\n promptsHeader.textContent = 'Registered Prompts:';\n Object.assign(promptsHeader.style, {\n fontWeight: 'bold',\n marginBottom: '5px'\n });\n\n const promptsContainer = document.createElement('ul');\n promptsContainer.className = 'webmcp-prompts-container';\n Object.assign(promptsContainer.style, {\n listStyle: 'none',\n padding: '0',\n margin: '0'\n });\n\n promptsList.appendChild(promptsHeader);\n promptsList.appendChild(promptsContainer);\n registeredItemsContainer.appendChild(promptsList);\n\n // Resources list\n const resourcesList = document.createElement('div');\n resourcesList.className = 'webmcp-resources-list';\n Object.assign(resourcesList.style, {\n padding: '10px'\n });\n\n const resourcesHeader = document.createElement('div');\n resourcesHeader.textContent = 'Registered Resources:';\n Object.assign(resourcesHeader.style, {\n fontWeight: 'bold',\n marginBottom: '5px'\n });\n\n const resourcesContainer = document.createElement('ul');\n resourcesContainer.className = 'webmcp-resources-container';\n Object.assign(resourcesContainer.style, {\n listStyle: 'none',\n padding: '0',\n margin: '0'\n });\n\n resourcesList.appendChild(resourcesHeader);\n resourcesList.appendChild(resourcesContainer);\n registeredItemsContainer.appendChild(resourcesList);\n\n // Add to main container and then to document - content panel first so it appears above trigger\n container.appendChild(contentPanel);\n container.appendChild(triggerButton);\n document.body.appendChild(container);\n }\n\n /**\n * Set widget position based on option\n * @private\n */\n _setWidgetPosition(container) {\n const {position, padding} = this.options;\n\n switch (position) {\n case 'bottom-right':\n Object.assign(container.style, {\n bottom: padding,\n right: padding,\n alignItems: 'flex-end'\n });\n break;\n case 'bottom-left':\n Object.assign(container.style, {\n bottom: padding,\n left: padding,\n alignItems: 'flex-start'\n });\n break;\n case 'top-right':\n Object.assign(container.style, {\n top: padding,\n right: padding,\n alignItems: 'flex-end'\n });\n break;\n case 'top-left':\n Object.assign(container.style, {\n top: padding,\n left: padding,\n alignItems: 'flex-start'\n });\n break;\n default:\n // Default to bottom-right\n Object.assign(container.style, {\n bottom: padding,\n right: padding,\n alignItems: 'flex-end'\n });\n }\n }\n\n /**\n * Create the connection form\n * @private\n */\n _createConnectionForm(container) {\n const form = document.createElement('div');\n Object.assign(form.style, {\n marginBottom: '8px',\n });\n\n // Token input field\n const inputGroup = document.createElement('div');\n Object.assign(inputGroup.style, {\n display: 'flex',\n marginBottom: '8px',\n });\n\n const tokenInput = document.createElement('input');\n tokenInput.type = 'text';\n tokenInput.className = 'webmcp-token-input';\n tokenInput.placeholder = 'Paste connection token';\n Object.assign(tokenInput.style, {\n flex: '1',\n padding: '8px',\n border: '1px solid #ccc',\n borderRadius: '4px 0 0 4px',\n fontSize: '12px'\n });\n\n const connectButton = document.createElement('button');\n connectButton.className = 'webmcp-connect-btn';\n connectButton.textContent = 'Connect';\n Object.assign(connectButton.style, {\n padding: '8px 12px',\n backgroundColor: this.options.color,\n color: 'white',\n border: 'none',\n borderRadius: '0 4px 4px 0',\n cursor: 'pointer',\n fontSize: '12px'\n });\n\n inputGroup.appendChild(tokenInput);\n inputGroup.appendChild(connectButton);\n\n const disconnectButton = document.createElement('button');\n disconnectButton.className = 'webmcp-disconnect-btn';\n disconnectButton.textContent = 'Disconnect';\n Object.assign(disconnectButton.style, {\n padding: '8px 12px',\n backgroundColor: '#dc3545',\n color: 'white',\n border: 'none',\n borderRadius: '4px',\n cursor: 'pointer',\n fontSize: '12px',\n width: '100%',\n display: 'none'\n });\n\n form.appendChild(inputGroup);\n form.appendChild(disconnectButton);\n container.appendChild(form);\n }\n\n /**\n * Set up event listeners for the widget\n * @private\n */\n _setupEventListeners() {\n const container = document.getElementById(this.elementId);\n if (!container) return;\n\n // Trigger button click - expand/collapse\n const trigger = container.querySelector('.webmcp-trigger');\n trigger.addEventListener('click', () => {\n this._toggleExpanded();\n });\n\n // Close button click - collapse\n const closeBtn = container.querySelector('.webmcp-close');\n closeBtn.addEventListener('click', () => {\n this._toggleExpanded(false);\n });\n\n // Connect button click\n const connectBtn = container.querySelector('.webmcp-connect-btn');\n connectBtn.addEventListener('click', () => {\n const tokenInput = container.querySelector('.webmcp-token-input');\n this.connect(tokenInput.value);\n });\n\n // Disconnect button click\n const disconnectBtn = container.querySelector('.webmcp-disconnect-btn');\n disconnectBtn.addEventListener('click', () => {\n this.disconnect();\n });\n\n // User activity detection to reset inactivity timer\n document.addEventListener('mousemove', () => this._resetInactivityTimer());\n document.addEventListener('keypress', () => this._resetInactivityTimer());\n document.addEventListener('click', () => this._resetInactivityTimer());\n document.addEventListener('scroll', () => this._resetInactivityTimer());\n }\n\n /**\n * Toggle the expanded state of the widget\n * @private\n */\n _toggleExpanded(force = null) {\n const container = document.getElementById(this.elementId);\n if (!container) return;\n\n const contentPanel = container.querySelector('.webmcp-content');\n this.isExpanded = force !== null ? force : !this.isExpanded;\n\n if (this.isExpanded) {\n contentPanel.style.display = 'block';\n } else {\n contentPanel.style.display = 'none';\n }\n\n this._resetInactivityTimer();\n }\n\n /**\n * Update the status indicator\n * @private\n */\n _updateStatus(status, message) {\n this._currentStatus = status;\n this._emit('statusChange', { status, message: message || status });\n\n const container = document.getElementById(this.elementId);\n if (!container) return;\n\n const statusIndicator = container.querySelector('.webmcp-status');\n if (!statusIndicator) return;\n\n // Clear existing classes\n statusIndicator.classList.remove('connected', 'disconnected', 'connecting', 'pending-auth');\n\n // Set new status\n statusIndicator.textContent = message || status;\n\n // Apply styling based on status\n switch (status) {\n case 'connected':\n Object.assign(statusIndicator.style, {\n backgroundColor: '#d4edda',\n color: '#155724'\n });\n break;\n case 'disconnected':\n Object.assign(statusIndicator.style, {\n backgroundColor: '#f8d7da',\n color: '#721c24'\n });\n break;\n case 'connecting':\n Object.assign(statusIndicator.style, {\n backgroundColor: '#fff3cd',\n color: '#856404'\n });\n break;\n case 'pending-auth':\n Object.assign(statusIndicator.style, {\n backgroundColor: '#d1ecf1',\n color: '#0c5460'\n });\n break;\n }\n }\n\n /**\n * Update UI based on connection state\n * @private\n */\n _updateConnectionUI(isConnected) {\n const container = document.getElementById(this.elementId);\n if (!container) return;\n\n const tokenInput = container.querySelector('.webmcp-token-input');\n const connectBtn = container.querySelector('.webmcp-connect-btn');\n const disconnectBtn = container.querySelector('.webmcp-disconnect-btn');\n const registeredItemsContainer = container.querySelector('.webmcp-registered-items');\n\n if (isConnected) {\n tokenInput.style.display = 'none';\n connectBtn.style.display = 'none';\n disconnectBtn.style.display = 'block';\n registeredItemsContainer.style.display = 'block';\n\n // Update the trigger button to show connected state\n const trigger = container.querySelector('.webmcp-trigger');\n trigger.innerHTML = '\u2713';\n trigger.style.color = 'white';\n trigger.style.fontWeight = 'bold';\n } else {\n tokenInput.style.display = 'block';\n connectBtn.style.display = 'block';\n disconnectBtn.style.display = 'none';\n registeredItemsContainer.style.display = 'none';\n\n // Reset the trigger button\n const trigger = container.querySelector('.webmcp-trigger');\n trigger.innerHTML = '';\n }\n }\n\n /**\n * Update tools list in UI\n * @private\n */\n _updateToolsList() {\n const container = document.getElementById(this.elementId);\n if (!container) return;\n\n const toolsContainer = container.querySelector('.webmcp-tools-container');\n if (!toolsContainer) return;\n\n // Clear current list\n toolsContainer.innerHTML = '';\n\n if (this.availableTools.size === 0) {\n const emptyMessage = document.createElement('li');\n emptyMessage.textContent = 'No tools registered';\n emptyMessage.style.fontStyle = 'italic';\n emptyMessage.style.color = '#666';\n toolsContainer.appendChild(emptyMessage);\n return;\n }\n\n // Add each tool to the list\n this.availableTools.forEach((tool, name) => {\n const toolItem = document.createElement('li');\n Object.assign(toolItem.style, {\n padding: '5px 0',\n borderBottom: '1px solid #eee'\n });\n\n const toolName = document.createElement('strong');\n toolName.textContent = name;\n\n const toolDesc = document.createElement('div');\n toolDesc.textContent = tool.description;\n toolDesc.style.fontSize = '10px';\n toolDesc.style.color = '#666';\n\n toolItem.appendChild(toolName);\n toolItem.appendChild(toolDesc);\n toolsContainer.appendChild(toolItem);\n });\n }\n\n /**\n * Update prompts list in UI\n * @private\n */\n _updatePromptsList() {\n const container = document.getElementById(this.elementId);\n if (!container) return;\n\n const promptsContainer = container.querySelector('.webmcp-prompts-container');\n if (!promptsContainer) return;\n\n // Clear current list\n promptsContainer.innerHTML = '';\n\n if (this.availablePrompts.size === 0) {\n const emptyMessage = document.createElement('li');\n emptyMessage.textContent = 'No prompts registered';\n emptyMessage.style.fontStyle = 'italic';\n emptyMessage.style.color = '#666';\n promptsContainer.appendChild(emptyMessage);\n return;\n }\n\n // Add each prompt to the list\n this.availablePrompts.forEach((prompt, name) => {\n const promptItem = document.createElement('li');\n Object.assign(promptItem.style, {\n padding: '5px 0',\n borderBottom: '1px solid #eee'\n });\n\n const promptName = document.createElement('strong');\n promptName.textContent = name;\n\n const promptDesc = document.createElement('div');\n promptDesc.textContent = prompt.description;\n promptDesc.style.fontSize = '10px';\n promptDesc.style.color = '#666';\n\n promptItem.appendChild(promptName);\n promptItem.appendChild(promptDesc);\n promptsContainer.appendChild(promptItem);\n });\n }\n\n /**\n * Update resources list in UI\n * @private\n */\n _updateResourcesList() {\n const container = document.getElementById(this.elementId);\n if (!container) return;\n\n const resourcesContainer = container.querySelector('.webmcp-resources-container');\n if (!resourcesContainer) return;\n\n // Clear current list\n resourcesContainer.innerHTML = '';\n\n if (this.availableResources.size === 0) {\n const emptyMessage = document.createElement('li');\n emptyMessage.textContent = 'No resources registered';\n emptyMessage.style.fontStyle = 'italic';\n emptyMessage.style.color = '#666';\n resourcesContainer.appendChild(emptyMessage);\n return;\n }\n\n // Add each resource to the list\n this.availableResources.forEach((resource, name) => {\n const resourceItem = document.createElement('li');\n Object.assign(resourceItem.style, {\n padding: '5px 0',\n borderBottom: '1px solid #eee'\n });\n\n const resourceName = document.createElement('strong');\n resourceName.textContent = name;\n\n const resourceDesc = document.createElement('div');\n resourceDesc.textContent = resource.description +\n (resource.isTemplate ? ' (Template)' : '');\n resourceDesc.style.fontSize = '10px';\n resourceDesc.style.color = '#666';\n\n resourceItem.appendChild(resourceName);\n resourceItem.appendChild(resourceDesc);\n resourcesContainer.appendChild(resourceItem);\n });\n }\n\n /**\n * Reset the inactivity timer\n * @private\n */\n _resetInactivityTimer() {\n // Clear existing timer\n if (this.inactivityTimer) {\n clearTimeout(this.inactivityTimer);\n }\n\n // Set new timer\n this.inactivityTimer = setTimeout(() => {\n this._handleInactivity();\n }, this.options.inactivityTimeout);\n }\n\n /**\n * Handle user inactivity\n * @private\n */\n _handleInactivity() {\n console.log('Inactivity timeout reached, disconnecting');\n\n // Disconnect if connected\n if (this.isConnected) {\n this.disconnect();\n }\n\n // Minimize UI\n this._toggleExpanded(false);\n\n // Clear the stored token\n sessionStorage.removeItem(this.SESSION_STORAGE_KEY);\n }\n\n\n /**\n * Connect to the WebSocket server\n * @public\n * @param {string} connectionToken - The encoded connection token\n */\n async connect(connectionToken) {\n if (!connectionToken) {\n this._updateStatus('disconnected', 'Error: No token provided');\n return;\n }\n\n // Store for reconnection attempts\n this._lastConnectionToken = connectionToken;\n\n // Update UI to show connecting state\n this._updateStatus('connecting', 'Connecting...');\n\n try {\n // Process the connection token\n if (!this._processConnectionToken(connectionToken)) {\n return;\n }\n\n // Store the connection info in sessionStorage for page navigations\n const connectionInfo = {\n token: connectionToken,\n server: this.currentServer,\n host: this._format(window.location.host)\n };\n\n // Check if we have connection data already in sessionStorage\n const storedConnectionInfo = sessionStorage.getItem(this.SESSION_STORAGE_KEY);\n let skipRegistration = false;\n\n if (storedConnectionInfo) {\n try {\n const connectionInfo = JSON.parse(storedConnectionInfo);\n // If we already have a valid token and server, we can skip registration\n if (connectionInfo.server === this.currentServer &&\n connectionInfo.host === this._format(window.location.host)) {\n skipRegistration = true;\n }\n } catch (error) {\n console.error('Error parsing stored connection info:', error);\n }\n }\n\n if (!skipRegistration) {\n // First register with server\n const response = await this._registerWithServer(connectionToken);\n\n if (!response.token) {\n this._updateStatus('disconnected', 'Registration failed');\n return;\n }\n\n // Save the new token\n connectionInfo.token = response.token;\n this.currentToken = response.token;\n\n sessionStorage.setItem(this.SESSION_STORAGE_KEY, JSON.stringify(connectionInfo));\n }\n\n // Now connect to the actual channel\n const serverUrl = `${this.currentServer}${this.currentChannel}?token=${this.currentToken}`;\n\n // Update UI\n this._updateStatus('connecting', 'Connecting to channel...');\n\n // Create WebSocket connection with the path and token\n this.socket = new WebSocket(serverUrl);\n\n // Set up socket event listeners\n this._setupSocketListeners();\n\n // Reset inactivity timer\n this._resetInactivityTimer();\n\n } catch (error) {\n console.error('Connection error:', error);\n this._updateStatus('disconnected', `Error: ${error.message}`);\n }\n }\n\n /**\n * Disconnect from WebSocket server\n * @public\n */\n disconnect() {\n // Close the WebSocket connection if it exists\n if (this.socket) {\n this.socket.close();\n this.socket = null;\n }\n\n this.isConnected = false;\n this._updateStatus('disconnected', 'Disconnected');\n this._updateConnectionUI(false);\n\n // Reset state\n this.currentToken = '';\n this.currentServer = '';\n this.currentChannel = '';\n\n // Remove the token from sessionStorage\n sessionStorage.removeItem(this.SESSION_STORAGE_KEY);\n\n // Clear items from sessionStorage\n this._clearStoredItems();\n }\n\n /**\n * Process connection token\n * @private\n * @param {string} encodedToken - The encoded connection token\n * @returns {boolean} - True if processing was successful\n */\n _processConnectionToken(encodedToken) {\n try {\n // Decode the base64 token\n const jsonStr = atob(encodedToken);\n const connectionData = JSON.parse(jsonStr);\n\n // Extract server and token\n const {server, token} = connectionData;\n\n if (!server || !token) {\n this._updateStatus('disconnected', 'Invalid token');\n return false;\n }\n\n // Store connection info\n this.currentServer = server;\n this.currentToken = token;\n\n // Format channel based on hostname\n this.currentChannel = `/${this._format(window.location.host)}`;\n\n return true;\n } catch (error) {\n this._updateStatus('disconnected', `Unable to parse token`);\n return false;\n }\n }\n\n /**\n * Register with server using connection token\n * @private\n * @param {string} encodedToken - The encoded connection token\n * @returns {Promise<{ token: string }>} - Resolves to true if registration was successful\n */\n _registerWithServer(encodedToken) {\n // Update UI\n this._updateStatus('pending-auth', 'Registering...');\n\n // Connect to the registration endpoint\n const regSocket = new WebSocket(`${this.currentServer}${this.REGISTER_PATH}`);\n\n return new Promise((resolve, reject) => {\n // Connection opened - send the token\n regSocket.addEventListener('open', (event) => {\n console.log('Registration connection established');\n\n // Send the original encoded token back to the server\n const jsonStr = atob(encodedToken);\n const connectionData = JSON.parse(jsonStr);\n connectionData.host = this._format(window.location.host);\n regSocket.send(btoa(JSON.stringify(connectionData)));\n });\n\n // Listen for registration response\n regSocket.addEventListener('message', (event) => {\n try {\n const message = JSON.parse(event.data);\n\n if (message.type === 'registerSuccess' && message.token) {\n console.log(`Registration successful: ${message.message}`);\n\n // Registration complete, can now connect to channel\n resolve({ token: message.token });\n } else if (message.type === 'error') {\n console.error(`Registration failed: ${message.message}`);\n this._updateStatus('disconnected', `Registration failed: ${message.message}`);\n reject(new Error(message.message));\n }\n } catch (error) {\n console.error(`Error parsing registration response: ${error.message}`);\n this._updateStatus('disconnected', 'Error parsing server response');\n reject(error);\n }\n });\n\n // Handle registration errors\n regSocket.addEventListener('error', (event) => {\n console.error('Registration connection error');\n this._updateStatus('disconnected', 'Registration connection error');\n sessionStorage.removeItem(this.SESSION_STORAGE_KEY);\n reject(new Error('Connection error'));\n });\n\n // Handle registration connection close\n regSocket.addEventListener('close', (event) => {\n console.log(`Registration connection closed: ${event.code} ${event.reason}`);\n\n if (event.code !== 1000) {\n // If it wasn't a normal closure, show an error\n this._updateStatus('disconnected', 'Registration failed');\n sessionStorage.removeItem(this.SESSION_STORAGE_KEY);\n reject(new Error('Connection closed'));\n }\n });\n });\n }\n\n /**\n * Set up WebSocket event listeners for direct connection\n * @private\n */\n _setupSocketListeners() {\n if (!this.socket) {\n console.error('Cannot set up socket listeners: WebSocket not available');\n return;\n }\n\n // Set up socket open handler\n this.socket.addEventListener('open', () => {\n this.isConnected = true;\n this._reconnectAttempts = 0;\n this._updateStatus('connected', `Connected to ${this.currentChannel}`);\n this._updateConnectionUI(true);\n this._emit('connected', { channel: this.currentChannel, server: this.currentServer });\n console.log('WebMCP connection established');\n this._registerItemsWithServer();\n });\n\n // Set up socket close handler\n this.socket.addEventListener('close', (event) => {\n this.isConnected = false;\n console.log(`Connection closed: ${event.code} ${event.reason}`);\n\n // Normal closure \u2014 no retry\n if (event.code === 1000) {\n this._updateStatus('disconnected', 'Disconnected');\n this._updateConnectionUI(false);\n this._emit('disconnected', { code: event.code, reason: event.reason });\n return;\n }\n\n // Abnormal closure \u2014 try to reconnect\n if (this._reconnectAttempts < this._maxReconnectAttempts && this._lastConnectionToken) {\n this._reconnectAttempts++;\n const delay = this._reconnectDelay * this._reconnectAttempts;\n console.log(`Reconnecting (attempt ${this._reconnectAttempts}/${this._maxReconnectAttempts}) in ${delay}ms...`);\n this._updateStatus('connecting', `Reconectando (${this._reconnectAttempts}/${this._maxReconnectAttempts})...`);\n this._emit('reconnecting', {\n attempt: this._reconnectAttempts,\n maxAttempts: this._maxReconnectAttempts,\n delay\n });\n setTimeout(() => {\n this.connect(this._lastConnectionToken);\n }, delay);\n return;\n }\n\n // Max retries exceeded or no token \u2014 give up\n this._updateStatus('disconnected', 'Disconnected');\n this._updateConnectionUI(false);\n this._emit('disconnected', { code: event.code, reason: event.reason });\n this.currentToken = '';\n this.currentServer = '';\n this.currentChannel = '';\n sessionStorage.removeItem(this.SESSION_STORAGE_KEY);\n });\n\n // Set up socket error handler\n this.socket.addEventListener('error', () => {\n // Suppress noisy errors during reconnection attempts\n if (this._reconnectAttempts > 0) return;\n\n console.error('WebSocket error');\n\n if (this.isConnected) {\n this._updateStatus('disconnected', 'Connection error occurred');\n } else {\n this._updateStatus('disconnected', 'Connection failed');\n }\n\n sessionStorage.removeItem(this.SESSION_STORAGE_KEY);\n });\n\n // Set up socket message handler\n this.socket.addEventListener('message', (event) => {\n try {\n const message = JSON.parse(event.data);\n this._handleServerMessage(message);\n } catch (error) {\n console.error(`Error parsing message: ${error.message}`);\n }\n });\n }\n\n /**\n * Handle messages from the server\n * @private\n * @param {Object} message - The parsed message object\n */\n _handleServerMessage(message) {\n switch (message.type) {\n case 'welcome':\n console.log(`Server says: ${message.message}`);\n this._sendMessage({\n type: 'clientInfo',\n userAgent: navigator.userAgent,\n url: window.location.href,\n hostname: window.location.hostname,\n language: navigator.language,\n screenWidth: window.innerWidth,\n screenHeight: window.innerHeight,\n timestamp: Date.now()\n });\n break;\n\n case 'toolRegistered':\n console.log(`Tool registered with server: ${message.name}`);\n this._emit('toolRegistered', { name: message.name });\n break;\n\n case 'promptRegistered':\n console.log(`Prompt registered with server: ${message.name}`);\n break;\n\n case 'resourceRegistered':\n console.log(`Resource registered with server: ${message.name}`);\n break;\n\n case 'callTool':\n // Server is asking us to execute a tool\n this._handleToolCall(message);\n break;\n\n case 'getPrompt':\n // Server is asking us to provide a prompt\n this._handleGetPrompt(message);\n break;\n\n case 'readResource':\n // Server is asking us to provide a resource\n this._handleReadResource(message);\n break;\n\n case 'createSamplingMessage':\n // Server is asking us to create a sampling message\n this._handleCreateSamplingMessage(message);\n break;\n\n case 'listTools':\n // Server is asking for available tools\n this._sendToolsList(message.id);\n break;\n\n case 'listPrompts':\n // Server is asking for available prompts\n this._sendPromptsList(message.id);\n break;\n\n case 'listResources':\n // Server is asking for available resources\n this._sendResourcesList(message.id);\n break;\n\n case 'ping':\n // Respond to ping\n this._sendMessage({\n type: 'pong',\n id: message.id,\n timestamp: Date.now()\n });\n break;\n\n case 'createTool':\n this._handleCreateTool(message);\n break;\n\n case 'removeTool':\n if (message.name && this.availableTools.has(message.name)) {\n this.availableTools.delete(message.name);\n this.registeredTools.delete(message.name);\n this._saveItemsToStorage();\n this._updateToolsList();\n this._emit('toolRemoved', { name: message.name });\n console.log(`Tool removed by server: ${message.name}`);\n }\n break;\n\n case 'removeAllTools':\n this.availableTools.clear();\n this.registeredTools.clear();\n this._saveItemsToStorage();\n this._updateToolsList();\n this._emit('toolRemoved', { name: '*' });\n console.log('All tools removed by server');\n break;\n\n case 'getClientInfo':\n this._sendMessage({\n id: message.id,\n type: 'clientInfoResponse',\n userAgent: navigator.userAgent,\n url: window.location.href,\n hostname: window.location.hostname,\n language: navigator.language,\n screenWidth: window.innerWidth,\n screenHeight: window.innerHeight,\n timestamp: Date.now()\n });\n break;\n\n case 'clipboardCopy':\n if (message.text && navigator.clipboard) {\n navigator.clipboard.writeText(message.text).then(() => {\n console.log('Token copiado al portapapeles');\n }).catch(err => {\n console.error('Error copiando al portapapeles:', err);\n });\n }\n break;\n\n case 'error':\n console.error(`Server error: ${message.message}`);\n this._emit('error', { message: message.message });\n break;\n\n default:\n console.warn(`Unknown message type: ${message.type}`);\n }\n }\n\n /**\n * Handle createTool request from server (via built-in agregar-tool)\n * @private\n * @param {Object} message - The parsed message object\n */\n _handleCreateTool(message) {\n const {id, name, description, code, parametros} = message;\n try {\n let props = {};\n if (parametros) props = JSON.parse(parametros);\n const schema = { type: 'object', properties: props };\n const fn = new Function('args', code);\n this.registerTool(name, description, schema, fn);\n this._sendMessage({\n id,\n type: 'toolResponse',\n result: { content: [{ type: 'text', text: `Herramienta \"${name}\" registrada exitosamente` }] }\n });\n this._emit('toolCreated', { name });\n console.log(`Tool created by agent: ${name}`);\n } catch (e) {\n this._sendMessage({\n id,\n type: 'toolResponse',\n error: `Error creando herramienta: ${e.message}`\n });\n }\n }\n\n /**\n * Handle tool call from server\n * @private\n * @param {Object} message - The parsed message object\n */\n _handleToolCall(message) {\n const {id, tool, arguments: args} = message;\n\n console.log(`Tool call: ${tool} with args:`, args);\n\n if (!this.availableTools.has(tool)) {\n this._sendMessage({\n id,\n type: 'toolResponse',\n error: `Tool not found: ${tool}`\n });\n return;\n }\n\n // Execute the tool\n try {\n const toolObj = this.availableTools.get(tool);\n\n // Normalize result to MCP content format\n const wrapResult = (raw) => {\n if (raw && raw.content && Array.isArray(raw.content)) return raw;\n const text = typeof raw === 'string' ? raw : JSON.stringify(raw);\n return { content: [{ type: \"text\", text }] };\n };\n\n // Call the tool's execute function\n const result = toolObj.execute(args);\n\n // Handle promises\n if (result instanceof Promise) {\n result\n .then(resolvedResult => {\n this._sendMessage({\n id,\n type: 'toolResponse',\n result: wrapResult(resolvedResult)\n });\n })\n .catch(error => {\n this._sendMessage({\n id,\n type: 'toolResponse',\n error: error.message || 'Tool execution error'\n });\n });\n } else {\n // Send immediate result\n this._sendMessage({\n id,\n type: 'toolResponse',\n result: wrapResult(result)\n });\n }\n\n console.log(`Tool response sent for ${tool}`);\n } catch (error) {\n this._sendMessage({\n id,\n type: 'toolResponse',\n error: error.message || 'Tool execution error'\n });\n console.error(`Tool execution error:`, error);\n }\n }\n\n /**\n * Handle prompt request from server\n * @private\n * @param {Object} message - The parsed message object\n */\n _handleGetPrompt(message) {\n const {id, name, arguments: args} = message;\n\n console.log(`Prompt request: ${name} with args:`, args);\n\n if (!this.availablePrompts.has(name)) {\n this._sendMessage({\n id,\n type: 'promptResponse',\n error: `Prompt not found: ${name}`\n });\n return;\n }\n\n // Execute the prompt\n try {\n const promptObj = this.availablePrompts.get(name);\n\n // Call the prompt's execute function\n const result = promptObj.execute(args);\n\n // Handle promises\n if (result instanceof Promise) {\n result\n .then(resolvedResult => {\n this._sendMessage({\n id,\n type: 'promptResponse',\n result: resolvedResult\n });\n })\n .catch(error => {\n this._sendMessage({\n id,\n type: 'promptResponse',\n error: error.message || 'Prompt execution error'\n });\n });\n } else {\n // Send immediate result\n this._sendMessage({\n id,\n type: 'promptResponse',\n result\n });\n }\n\n console.log(`Prompt response sent for ${name}`);\n } catch (error) {\n this._sendMessage({\n id,\n type: 'promptResponse',\n error: error.message || 'Prompt execution error'\n });\n console.error(`Prompt execution error:`, error);\n }\n }\n\n /**\n * Handle resource request from server\n * @private\n * @param {Object} message - The parsed message object\n */\n _handleReadResource(message) {\n const {id, uri} = message;\n\n console.log(`Resource request: ${uri}`);\n\n // Find resource that handles this URI\n let resourceObj = null;\n\n // First check for direct URI match\n for (const resource of this.availableResources.values()) {\n if (!resource.isTemplate && resource.uri === uri) {\n resourceObj = resource;\n break;\n }\n }\n\n // If no direct match, check for template match\n if (!resourceObj) {\n for (const resource of this.availableResources.values()) {\n if (resource.isTemplate) {\n // Simple check - if URI starts with template prefix (before any parameters)\n const templatePrefix = resource.uriTemplate.split('{')[0];\n if (uri.startsWith(templatePrefix)) {\n resourceObj = resource;\n break;\n }\n }\n }\n }\n\n if (!resourceObj) {\n this._sendMessage({\n id,\n type: 'resourceResponse',\n error: `No resource handler found for URI: ${uri}`\n });\n return;\n }\n\n // Execute the resource provider\n try {\n // Call the resource's provide function\n const result = resourceObj.provide(uri);\n\n // Handle promises\n if (result instanceof Promise) {\n result\n .then(resolvedResult => {\n this._sendMessage({\n id,\n type: 'resourceResponse',\n result: resolvedResult\n });\n })\n .catch(error => {\n this._sendMessage({\n id,\n type: 'resourceResponse',\n error: error.message || 'Resource read error'\n });\n });\n } else {\n // Send immediate result\n this._sendMessage({\n id,\n type: 'resourceResponse',\n result\n });\n }\n\n console.log(`Resource response sent for ${uri}`);\n } catch (error) {\n this._sendMessage({\n id,\n type: 'resourceResponse',\n error: error.message || 'Resource read error'\n });\n console.error(`Resource read error:`, error);\n }\n }\n\n /**\n * Send available tools list\n * @private\n * @param {string} requestId - The request ID to respond to\n */\n _sendToolsList(requestId) {\n const toolsList = Array.from(this.availableTools.values()).map(tool => ({\n name: tool.name,\n description: tool.description,\n inputSchema: tool.inputSchema,\n }));\n\n this._sendMessage({\n id: requestId,\n type: 'listToolsResponse',\n tools: toolsList\n });\n\n console.log(`Sent tools list: ${toolsList.length} tools`);\n }\n\n /**\n * Send available prompts list\n * @private\n * @param {string} requestId - The request ID to respond to\n */\n _sendPromptsList(requestId) {\n const promptsList = Array.from(this.availablePrompts.values()).map(prompt => ({\n name: prompt.name,\n description: prompt.description,\n arguments: prompt.arguments,\n }));\n\n this._sendMessage({\n id: requestId,\n type: 'listPromptsResponse',\n prompts: promptsList\n });\n\n console.log(`Sent prompts list: ${promptsList.length} prompts`);\n }\n\n /**\n * Send available resources list\n * @private\n * @param {string} requestId - The request ID to respond to\n */\n _sendResourcesList(requestId) {\n const resources = [];\n const resourceTemplates = [];\n\n // Split resources and templates\n this.availableResources.forEach((resource) => {\n if (resource.isTemplate) {\n resourceTemplates.push({\n name: resource.name,\n description: resource.description,\n uriTemplate: resource.uriTemplate,\n mimeType: resource.mimeType\n });\n } else {\n resources.push({\n name: resource.name,\n description: resource.description,\n uri: resource.uri,\n mimeType: resource.mimeType\n });\n }\n });\n\n this._sendMessage({\n id: requestId,\n type: 'listResourcesResponse',\n resources,\n resourceTemplates\n });\n\n console.log(`Sent resources list: ${resources.length} resources, ${resourceTemplates.length} templates`);\n }\n\n /**\n * Send a message to the server via direct WebSocket\n * @private\n * @param {Object} message - The message object to send\n */\n _sendMessage(message) {\n if (!this.isConnected || !this.socket) {\n console.error('Cannot send message: not connected');\n return;\n }\n\n try {\n // Send the message directly through the WebSocket\n this.socket.send(JSON.stringify(message));\n return Promise.resolve();\n } catch (error) {\n console.error(`Error sending message: ${error.message}`);\n return Promise.reject(error);\n }\n }\n\n /**\n * Register all items with server that were registered while disconnected\n * @private\n */\n _registerItemsWithServer() {\n if (!this.isConnected) return;\n\n // Clear registration tracking sets - we'll re-register everything\n this.registeredTools = new Set();\n this.registeredPrompts = new Set();\n this.registeredResources = new Set();\n\n // Register all tools with the server\n this.availableTools.forEach((tool, name) => {\n this._sendMessage({\n type: 'registerTool',\n name,\n description: tool.description,\n inputSchema: tool.inputSchema\n });\n\n this.registeredTools.add(name);\n console.log(`Registering tool with server: ${name}`);\n });\n\n // Register all prompts with the server\n this.availablePrompts.forEach((prompt, name) => {\n this._sendMessage({\n type: 'registerPrompt',\n name,\n description: prompt.description,\n arguments: prompt.arguments\n });\n\n this.registeredPrompts.add(name);\n console.log(`Registering prompt with server: ${name}`);\n });\n\n // Register all resources with the server\n this.availableResources.forEach((resource, name) => {\n this._sendMessage({\n type: 'registerResource',\n name,\n description: resource.description,\n uri: resource.uri,\n uriTemplate: resource.uriTemplate,\n isTemplate: resource.isTemplate,\n mimeType: resource.mimeType\n });\n\n this.registeredResources.add(name);\n console.log(`Registering resource with server: ${name}`);\n });\n }\n\n /**\n * Register a tool\n * @public\n * @param {string} name - The name of the tool\n * @param {string} description - The description of the tool\n * @param {Object} schema - The schema for the tool's input\n * @param {Function} executeFn - The function to execute when the tool is called\n */\n registerTool(name, description, schema, executeFn) {\n if (!name) {\n console.error('Tool name is required');\n return;\n }\n\n // Add the tool to local registry\n this.availableTools.set(name, {\n name,\n description: description || `Tool: ${name}`,\n execute: executeFn || function (args) {\n return `Default implementation of ${name} with args: ${JSON.stringify(args)}`;\n },\n inputSchema: schema || {\n type: \"object\",\n properties: {}\n }\n });\n\n // Register the tool with the server if connected\n if (this.isConnected) {\n this._sendMessage({\n type: 'registerTool',\n name,\n description: description || `Tool: ${name}`,\n inputSchema: schema || {\n type: \"object\",\n properties: {}\n },\n });\n\n this.registeredTools.add(name);\n }\n\n // Save to session storage\n this._saveItemsToStorage();\n\n // Update tools display\n this._updateToolsList();\n console.log(`Tool registered: ${name}`);\n }\n\n /**\n * Unregister a tool\n * @public\n * @param {string} name - The name of the tool to unregister\n */\n unregisterTool(name) {\n if (!name) {\n console.error('Tool name is required');\n return;\n }\n\n if (!this.availableTools.has(name)) {\n console.warn(`Tool not found: ${name}`);\n return;\n }\n\n this.availableTools.delete(name);\n\n if (this.isConnected) {\n this._sendMessage({\n type: 'unregisterTool',\n name\n });\n }\n\n this.registeredTools.delete(name);\n this._saveItemsToStorage();\n this._updateToolsList();\n console.log(`Tool unregistered: ${name}`);\n }\n\n /**\n * Unregister all tools at once (single notification)\n * @public\n */\n unregisterAllTools() {\n if (this.availableTools.size === 0) return;\n\n this.availableTools.clear();\n this.registeredTools.clear();\n\n if (this.isConnected) {\n this._sendMessage({ type: 'unregisterAllTools' });\n }\n\n this._saveItemsToStorage();\n this._updateToolsList();\n console.log('All tools unregistered');\n }\n\n /**\n * Register a prompt\n * @public\n * @param {string} name - The name of the prompt\n * @param {string} description - The description of the prompt\n * @param {Array} promptArgs - The arguments for the prompt\n * @param {Function} executeFn - The function to execute when the prompt is called\n */\n registerPrompt(name, description, promptArgs, executeFn) {\n if (!name) {\n console.error('Prompt name is required');\n return;\n }\n\n // Add the prompt to local registry\n this.availablePrompts.set(name, {\n name,\n description: description || `Prompt: ${name}`,\n execute: executeFn || function (args) {\n return {\n messages: [{\n role: \"user\",\n content: {\n type: \"text\",\n text: `Default implementation of prompt ${name} with args: ${JSON.stringify(args)}`\n }\n }]\n };\n },\n arguments: promptArgs || []\n });\n\n // Register the prompt with the server if connected\n if (this.isConnected) {\n this._sendMessage({\n type: 'registerPrompt',\n name,\n description: description || `Prompt: ${name}`,\n arguments: promptArgs || []\n });\n\n this.registeredPrompts.add(name);\n }\n\n // Save to session storage\n this._saveItemsToStorage();\n\n // Update prompts display\n this._updatePromptsList();\n console.log(`Prompt registered: ${name}`);\n }\n\n /**\n * Unregister a prompt\n * @public\n * @param {string} name - The name of the prompt to unregister\n */\n unregisterPrompt(name) {\n if (!name) {\n console.error('Prompt name is required');\n return;\n }\n\n if (!this.availablePrompts.has(name)) {\n console.warn(`Prompt not found: ${name}`);\n return;\n }\n\n this.availablePrompts.delete(name);\n\n if (this.isConnected) {\n this._sendMessage({\n type: 'unregisterPrompt',\n name\n });\n }\n\n this.registeredPrompts.delete(name);\n this._saveItemsToStorage();\n this._updatePromptsList();\n console.log(`Prompt unregistered: ${name}`);\n }\n\n /**\n * Register a resource\n * @public\n * @param {string} name - The name of the resource\n * @param {string} description - The description of the resource\n * @param {Object} options - The resource options including uri, uriTemplate, and mimeType\n * @param {Function} provideFn - The function to execute when the resource is requested\n */\n registerResource(name, description, options, provideFn) {\n if (!name) {\n console.error('Resource name is required');\n return;\n }\n\n if (!options.uri && !options.uriTemplate) {\n console.error('Either uri or uriTemplate is required for a resource');\n return;\n }\n\n const isTemplate = !!options.uriTemplate;\n\n // Add the resource to local registry\n this.availableResources.set(name, {\n name,\n description: description || `Resource: ${name}`,\n uri: options.uri,\n uriTemplate: options.uriTemplate,\n isTemplate,\n mimeType: options.mimeType,\n provide: provideFn || function (uri) {\n return {\n contents: [{\n uri: uri,\n text: `Default implementation of resource ${name} for URI: ${uri}`,\n mimeType: options.mimeType || \"text/plain\"\n }]\n };\n }\n });\n\n // Register the resource with the server if connected\n if (this.isConnected) {\n this._sendMessage({\n type: 'registerResource',\n name,\n description: description || `Resource: ${name}`,\n uri: options.uri,\n uriTemplate: options.uriTemplate,\n isTemplate,\n mimeType: options.mimeType\n });\n\n this.registeredResources.add(name);\n }\n\n // Save to session storage\n this._saveItemsToStorage();\n\n // Update resources display\n this._updateResourcesList();\n console.log(`Resource registered: ${name}`);\n }\n\n /**\n * Unregister a resource\n * @public\n * @param {string} name - The name of the resource to unregister\n */\n unregisterResource(name) {\n if (!name) {\n console.error('Resource name is required');\n return;\n }\n\n if (!this.availableResources.has(name)) {\n console.warn(`Resource not found: ${name}`);\n return;\n }\n\n this.availableResources.delete(name);\n\n if (this.isConnected) {\n this._sendMessage({\n type: 'unregisterResource',\n name\n });\n }\n\n this.registeredResources.delete(name);\n this._saveItemsToStorage();\n this._updateResourcesList();\n console.log(`Resource unregistered: ${name}`);\n }\n\n /**\n * Handle sampling message creation request\n * @private\n * @param {Object} message - The parsed message object\n */\n _handleCreateSamplingMessage(message) {\n const {\n id,\n messages,\n systemPrompt,\n includeContext,\n temperature,\n maxTokens,\n stopSequences,\n metadata,\n modelPreferences\n } = message;\n\n console.log(`Sampling request received with ${messages?.length || 0} messages`);\n\n // Create a modal dialog to show the sampling request\n const modal = document.createElement('div');\n Object.assign(modal.style, {\n position: 'fixed',\n top: '0',\n left: '0',\n width: '100%',\n height: '100%',\n backgroundColor: 'rgba(0, 0, 0, 0.5)',\n display: 'flex',\n justifyContent: 'center',\n alignItems: 'center',\n zIndex: '10000'\n });\n\n // Create modal content\n const modalContent = document.createElement('div');\n Object.assign(modalContent.style, {\n backgroundColor: 'white',\n padding: '20px',\n borderRadius: '5px',\n maxWidth: '500px',\n width: '90%',\n maxHeight: '80%',\n overflow: 'auto'\n });\n\n // Create header\n const header = document.createElement('h3');\n header.textContent = 'Sampling Request';\n Object.assign(header.style, {\n margin: '0 0 15px 0',\n padding: '0 0 10px 0',\n borderBottom: '1px solid #ddd'\n });\n\n // Create content area to show messages\n const content = document.createElement('div');\n Object.assign(content.style, {\n marginBottom: '15px',\n maxHeight: '300px',\n overflow: 'auto',\n border: '1px solid #ddd',\n padding: '10px',\n backgroundColor: '#f9f9f9'\n });\n\n // Display messages\n if (messages && messages.length > 0) {\n messages.forEach(msg => {\n const msgDiv = document.createElement('div');\n Object.assign(msgDiv.style, {\n marginBottom: '10px',\n padding: '5px',\n borderRadius: '3px',\n backgroundColor: msg.role === 'user' ? '#e1f5fe' : '#f1f8e9'\n });\n\n const roleSpan = document.createElement('strong');\n roleSpan.textContent = msg.role === 'user' ? 'User: ' : 'Assistant: ';\n\n const contentSpan = document.createElement('span');\n if (msg.content.type === 'text') {\n contentSpan.textContent = msg.content.text;\n } else if (msg.content.type === 'image') {\n contentSpan.textContent = '[Image data]';\n }\n\n msgDiv.appendChild(roleSpan);\n msgDiv.appendChild(contentSpan);\n content.appendChild(msgDiv);\n });\n } else {\n content.textContent = 'No messages provided in sampling request';\n }\n\n // System prompt if available\n if (systemPrompt) {\n const sysPromptDiv = document.createElement('div');\n Object.assign(sysPromptDiv.style, {\n marginBottom: '10px',\n padding: '5px',\n backgroundColor: '#fff8e1'\n });\n\n const sysPromptLabel = document.createElement('strong');\n sysPromptLabel.textContent = 'System Prompt: ';\n\n const sysPromptContent = document.createElement('span');\n sysPromptContent.textContent = systemPrompt;\n\n sysPromptDiv.appendChild(sysPromptLabel);\n sysPromptDiv.appendChild(sysPromptContent);\n content.appendChild(sysPromptDiv);\n }\n\n // Create response input\n const responseLabel = document.createElement('label');\n responseLabel.textContent = 'Assistant Response:';\n Object.assign(responseLabel.style, {\n display: 'block',\n marginBottom: '5px',\n fontWeight: 'bold'\n });\n\n const responseInput = document.createElement('textarea');\n Object.assign(responseInput.style, {\n width: '100%',\n minHeight: '100px',\n padding: '10px',\n marginBottom: '15px',\n boxSizing: 'border-box'\n });\n\n // Create buttons\n const buttonContainer = document.createElement('div');\n Object.assign(buttonContainer.style, {\n display: 'flex',\n justifyContent: 'space-between'\n });\n\n const submitButton = document.createElement('button');\n submitButton.textContent = 'Submit Response';\n Object.assign(submitButton.style, {\n padding: '8px 15px',\n backgroundColor: '#4CAF50',\n color: 'white',\n border: 'none',\n borderRadius: '4px',\n cursor: 'pointer'\n });\n\n const cancelButton = document.createElement('button');\n cancelButton.textContent = 'Cancel';\n Object.assign(cancelButton.style, {\n padding: '8px 15px',\n backgroundColor: '#f44336',\n color: 'white',\n border: 'none',\n borderRadius: '4px',\n cursor: 'pointer'\n });\n\n // Add elements to modal\n buttonContainer.appendChild(cancelButton);\n buttonContainer.appendChild(submitButton);\n\n modalContent.appendChild(header);\n modalContent.appendChild(content);\n modalContent.appendChild(responseLabel);\n modalContent.appendChild(responseInput);\n modalContent.appendChild(buttonContainer);\n\n modal.appendChild(modalContent);\n document.body.appendChild(modal);\n\n // Focus the response input\n responseInput.focus();\n\n // Setup button handlers\n submitButton.addEventListener('click', () => {\n const responseText = responseInput.value.trim();\n if (responseText) {\n // Send response back to server\n this._sendMessage({\n id,\n type: 'samplingResponse',\n result: {\n model: 'web-user-input',\n role: 'assistant',\n content: {\n type: 'text',\n text: responseText\n }\n }\n });\n\n // Remove modal\n document.body.removeChild(modal);\n } else {\n alert('Please enter a response');\n }\n });\n\n cancelButton.addEventListener('click', () => {\n // Send error response\n this._sendMessage({\n id,\n type: 'samplingResponse',\n error: 'User cancelled sampling request'\n });\n\n // Remove modal\n document.body.removeChild(modal);\n });\n }\n}\n\n// Export for module usage\nif (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {\n module.exports = WebMCP;\n}\n"], + "mappings": "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", + "names": ["connectionInfo"] +}