{"version":3,"file":"claude-code-cli-wrapper.mjs","names":["#body","#init","crypto","Http2ServerRequest2","h2constants"],"sources":["../node_modules/.pnpm/@hono+node-server@1.19.14_hono@4.12.23/node_modules/@hono/node-server/dist/index.mjs","../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js","../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js","../src/batteries/llm/claude_code_cli/mcp_bridge.ts","../src/batteries/llm/claude_code_cli/cli_protocol.ts","../src/batteries/llm/claude_code_cli/wrapper.ts"],"sourcesContent":["// src/server.ts\nimport { createServer as createServerHTTP } from \"http\";\n\n// src/listener.ts\nimport { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from \"http2\";\n\n// src/request.ts\nimport { Http2ServerRequest } from \"http2\";\nimport { Readable } from \"stream\";\nvar RequestError = class extends Error {\n  constructor(message, options) {\n    super(message, options);\n    this.name = \"RequestError\";\n  }\n};\nvar toRequestError = (e) => {\n  if (e instanceof RequestError) {\n    return e;\n  }\n  return new RequestError(e.message, { cause: e });\n};\nvar GlobalRequest = global.Request;\nvar Request = class extends GlobalRequest {\n  constructor(input, options) {\n    if (typeof input === \"object\" && getRequestCache in input) {\n      input = input[getRequestCache]();\n    }\n    if (typeof options?.body?.getReader !== \"undefined\") {\n      ;\n      options.duplex ??= \"half\";\n    }\n    super(input, options);\n  }\n};\nvar newHeadersFromIncoming = (incoming) => {\n  const headerRecord = [];\n  const rawHeaders = incoming.rawHeaders;\n  for (let i = 0; i < rawHeaders.length; i += 2) {\n    const { [i]: key, [i + 1]: value } = rawHeaders;\n    if (key.charCodeAt(0) !== /*:*/\n    58) {\n      headerRecord.push([key, value]);\n    }\n  }\n  return new Headers(headerRecord);\n};\nvar wrapBodyStream = Symbol(\"wrapBodyStream\");\nvar newRequestFromIncoming = (method, url, headers, incoming, abortController) => {\n  const init = {\n    method,\n    headers,\n    signal: abortController.signal\n  };\n  if (method === \"TRACE\") {\n    init.method = \"GET\";\n    const req = new Request(url, init);\n    Object.defineProperty(req, \"method\", {\n      get() {\n        return \"TRACE\";\n      }\n    });\n    return req;\n  }\n  if (!(method === \"GET\" || method === \"HEAD\")) {\n    if (\"rawBody\" in incoming && incoming.rawBody instanceof Buffer) {\n      init.body = new ReadableStream({\n        start(controller) {\n          controller.enqueue(incoming.rawBody);\n          controller.close();\n        }\n      });\n    } else if (incoming[wrapBodyStream]) {\n      let reader;\n      init.body = new ReadableStream({\n        async pull(controller) {\n          try {\n            reader ||= Readable.toWeb(incoming).getReader();\n            const { done, value } = await reader.read();\n            if (done) {\n              controller.close();\n            } else {\n              controller.enqueue(value);\n            }\n          } catch (error) {\n            controller.error(error);\n          }\n        }\n      });\n    } else {\n      init.body = Readable.toWeb(incoming);\n    }\n  }\n  return new Request(url, init);\n};\nvar getRequestCache = Symbol(\"getRequestCache\");\nvar requestCache = Symbol(\"requestCache\");\nvar incomingKey = Symbol(\"incomingKey\");\nvar urlKey = Symbol(\"urlKey\");\nvar headersKey = Symbol(\"headersKey\");\nvar abortControllerKey = Symbol(\"abortControllerKey\");\nvar getAbortController = Symbol(\"getAbortController\");\nvar requestPrototype = {\n  get method() {\n    return this[incomingKey].method || \"GET\";\n  },\n  get url() {\n    return this[urlKey];\n  },\n  get headers() {\n    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);\n  },\n  [getAbortController]() {\n    this[getRequestCache]();\n    return this[abortControllerKey];\n  },\n  [getRequestCache]() {\n    this[abortControllerKey] ||= new AbortController();\n    return this[requestCache] ||= newRequestFromIncoming(\n      this.method,\n      this[urlKey],\n      this.headers,\n      this[incomingKey],\n      this[abortControllerKey]\n    );\n  }\n};\n[\n  \"body\",\n  \"bodyUsed\",\n  \"cache\",\n  \"credentials\",\n  \"destination\",\n  \"integrity\",\n  \"mode\",\n  \"redirect\",\n  \"referrer\",\n  \"referrerPolicy\",\n  \"signal\",\n  \"keepalive\"\n].forEach((k) => {\n  Object.defineProperty(requestPrototype, k, {\n    get() {\n      return this[getRequestCache]()[k];\n    }\n  });\n});\n[\"arrayBuffer\", \"blob\", \"clone\", \"formData\", \"json\", \"text\"].forEach((k) => {\n  Object.defineProperty(requestPrototype, k, {\n    value: function() {\n      return this[getRequestCache]()[k]();\n    }\n  });\n});\nObject.defineProperty(requestPrototype, Symbol.for(\"nodejs.util.inspect.custom\"), {\n  value: function(depth, options, inspectFn) {\n    const props = {\n      method: this.method,\n      url: this.url,\n      headers: this.headers,\n      nativeRequest: this[requestCache]\n    };\n    return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;\n  }\n});\nObject.setPrototypeOf(requestPrototype, Request.prototype);\nvar newRequest = (incoming, defaultHostname) => {\n  const req = Object.create(requestPrototype);\n  req[incomingKey] = incoming;\n  const incomingUrl = incoming.url || \"\";\n  if (incomingUrl[0] !== \"/\" && // short-circuit for performance. most requests are relative URL.\n  (incomingUrl.startsWith(\"http://\") || incomingUrl.startsWith(\"https://\"))) {\n    if (incoming instanceof Http2ServerRequest) {\n      throw new RequestError(\"Absolute URL for :path is not allowed in HTTP/2\");\n    }\n    try {\n      const url2 = new URL(incomingUrl);\n      req[urlKey] = url2.href;\n    } catch (e) {\n      throw new RequestError(\"Invalid absolute URL\", { cause: e });\n    }\n    return req;\n  }\n  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;\n  if (!host) {\n    throw new RequestError(\"Missing host header\");\n  }\n  let scheme;\n  if (incoming instanceof Http2ServerRequest) {\n    scheme = incoming.scheme;\n    if (!(scheme === \"http\" || scheme === \"https\")) {\n      throw new RequestError(\"Unsupported scheme\");\n    }\n  } else {\n    scheme = incoming.socket && incoming.socket.encrypted ? \"https\" : \"http\";\n  }\n  const url = new URL(`${scheme}://${host}${incomingUrl}`);\n  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\\d+$/, \"\")) {\n    throw new RequestError(\"Invalid host header\");\n  }\n  req[urlKey] = url.href;\n  return req;\n};\n\n// src/response.ts\nvar responseCache = Symbol(\"responseCache\");\nvar getResponseCache = Symbol(\"getResponseCache\");\nvar cacheKey = Symbol(\"cache\");\nvar GlobalResponse = global.Response;\nvar Response2 = class _Response {\n  #body;\n  #init;\n  [getResponseCache]() {\n    delete this[cacheKey];\n    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);\n  }\n  constructor(body, init) {\n    let headers;\n    this.#body = body;\n    if (init instanceof _Response) {\n      const cachedGlobalResponse = init[responseCache];\n      if (cachedGlobalResponse) {\n        this.#init = cachedGlobalResponse;\n        this[getResponseCache]();\n        return;\n      } else {\n        this.#init = init.#init;\n        headers = new Headers(init.#init.headers);\n      }\n    } else {\n      this.#init = init;\n    }\n    if (typeof body === \"string\" || typeof body?.getReader !== \"undefined\" || body instanceof Blob || body instanceof Uint8Array) {\n      ;\n      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];\n    }\n  }\n  get headers() {\n    const cache = this[cacheKey];\n    if (cache) {\n      if (!(cache[2] instanceof Headers)) {\n        cache[2] = new Headers(\n          cache[2] || { \"content-type\": \"text/plain; charset=UTF-8\" }\n        );\n      }\n      return cache[2];\n    }\n    return this[getResponseCache]().headers;\n  }\n  get status() {\n    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;\n  }\n  get ok() {\n    const status = this.status;\n    return status >= 200 && status < 300;\n  }\n};\n[\"body\", \"bodyUsed\", \"redirected\", \"statusText\", \"trailers\", \"type\", \"url\"].forEach((k) => {\n  Object.defineProperty(Response2.prototype, k, {\n    get() {\n      return this[getResponseCache]()[k];\n    }\n  });\n});\n[\"arrayBuffer\", \"blob\", \"clone\", \"formData\", \"json\", \"text\"].forEach((k) => {\n  Object.defineProperty(Response2.prototype, k, {\n    value: function() {\n      return this[getResponseCache]()[k]();\n    }\n  });\n});\nObject.defineProperty(Response2.prototype, Symbol.for(\"nodejs.util.inspect.custom\"), {\n  value: function(depth, options, inspectFn) {\n    const props = {\n      status: this.status,\n      headers: this.headers,\n      ok: this.ok,\n      nativeResponse: this[responseCache]\n    };\n    return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;\n  }\n});\nObject.setPrototypeOf(Response2, GlobalResponse);\nObject.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);\n\n// src/utils.ts\nasync function readWithoutBlocking(readPromise) {\n  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);\n}\nfunction writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {\n  const cancel = (error) => {\n    reader.cancel(error).catch(() => {\n    });\n  };\n  writable.on(\"close\", cancel);\n  writable.on(\"error\", cancel);\n  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);\n  return reader.closed.finally(() => {\n    writable.off(\"close\", cancel);\n    writable.off(\"error\", cancel);\n  });\n  function handleStreamError(error) {\n    if (error) {\n      writable.destroy(error);\n    }\n  }\n  function onDrain() {\n    reader.read().then(flow, handleStreamError);\n  }\n  function flow({ done, value }) {\n    try {\n      if (done) {\n        writable.end();\n      } else if (!writable.write(value)) {\n        writable.once(\"drain\", onDrain);\n      } else {\n        return reader.read().then(flow, handleStreamError);\n      }\n    } catch (e) {\n      handleStreamError(e);\n    }\n  }\n}\nfunction writeFromReadableStream(stream, writable) {\n  if (stream.locked) {\n    throw new TypeError(\"ReadableStream is locked.\");\n  } else if (writable.destroyed) {\n    return;\n  }\n  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);\n}\nvar buildOutgoingHttpHeaders = (headers) => {\n  const res = {};\n  if (!(headers instanceof Headers)) {\n    headers = new Headers(headers ?? void 0);\n  }\n  const cookies = [];\n  for (const [k, v] of headers) {\n    if (k === \"set-cookie\") {\n      cookies.push(v);\n    } else {\n      res[k] = v;\n    }\n  }\n  if (cookies.length > 0) {\n    res[\"set-cookie\"] = cookies;\n  }\n  res[\"content-type\"] ??= \"text/plain; charset=UTF-8\";\n  return res;\n};\n\n// src/utils/response/constants.ts\nvar X_ALREADY_SENT = \"x-hono-already-sent\";\n\n// src/globals.ts\nimport crypto from \"crypto\";\nif (typeof global.crypto === \"undefined\") {\n  global.crypto = crypto;\n}\n\n// src/listener.ts\nvar outgoingEnded = Symbol(\"outgoingEnded\");\nvar incomingDraining = Symbol(\"incomingDraining\");\nvar DRAIN_TIMEOUT_MS = 500;\nvar MAX_DRAIN_BYTES = 64 * 1024 * 1024;\nvar drainIncoming = (incoming) => {\n  const incomingWithDrainState = incoming;\n  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {\n    return;\n  }\n  incomingWithDrainState[incomingDraining] = true;\n  if (incoming instanceof Http2ServerRequest2) {\n    try {\n      ;\n      incoming.stream?.close?.(h2constants.NGHTTP2_NO_ERROR);\n    } catch {\n    }\n    return;\n  }\n  let bytesRead = 0;\n  const cleanup = () => {\n    clearTimeout(timer);\n    incoming.off(\"data\", onData);\n    incoming.off(\"end\", cleanup);\n    incoming.off(\"error\", cleanup);\n  };\n  const forceClose = () => {\n    cleanup();\n    const socket = incoming.socket;\n    if (socket && !socket.destroyed) {\n      socket.destroySoon();\n    }\n  };\n  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);\n  timer.unref?.();\n  const onData = (chunk) => {\n    bytesRead += chunk.length;\n    if (bytesRead > MAX_DRAIN_BYTES) {\n      forceClose();\n    }\n  };\n  incoming.on(\"data\", onData);\n  incoming.on(\"end\", cleanup);\n  incoming.on(\"error\", cleanup);\n  incoming.resume();\n};\nvar handleRequestError = () => new Response(null, {\n  status: 400\n});\nvar handleFetchError = (e) => new Response(null, {\n  status: e instanceof Error && (e.name === \"TimeoutError\" || e.constructor.name === \"TimeoutError\") ? 504 : 500\n});\nvar handleResponseError = (e, outgoing) => {\n  const err = e instanceof Error ? e : new Error(\"unknown error\", { cause: e });\n  if (err.code === \"ERR_STREAM_PREMATURE_CLOSE\") {\n    console.info(\"The user aborted a request.\");\n  } else {\n    console.error(e);\n    if (!outgoing.headersSent) {\n      outgoing.writeHead(500, { \"Content-Type\": \"text/plain\" });\n    }\n    outgoing.end(`Error: ${err.message}`);\n    outgoing.destroy(err);\n  }\n};\nvar flushHeaders = (outgoing) => {\n  if (\"flushHeaders\" in outgoing && outgoing.writable) {\n    outgoing.flushHeaders();\n  }\n};\nvar responseViaCache = async (res, outgoing) => {\n  let [status, body, header] = res[cacheKey];\n  let hasContentLength = false;\n  if (!header) {\n    header = { \"content-type\": \"text/plain; charset=UTF-8\" };\n  } else if (header instanceof Headers) {\n    hasContentLength = header.has(\"content-length\");\n    header = buildOutgoingHttpHeaders(header);\n  } else if (Array.isArray(header)) {\n    const headerObj = new Headers(header);\n    hasContentLength = headerObj.has(\"content-length\");\n    header = buildOutgoingHttpHeaders(headerObj);\n  } else {\n    for (const key in header) {\n      if (key.length === 14 && key.toLowerCase() === \"content-length\") {\n        hasContentLength = true;\n        break;\n      }\n    }\n  }\n  if (!hasContentLength) {\n    if (typeof body === \"string\") {\n      header[\"Content-Length\"] = Buffer.byteLength(body);\n    } else if (body instanceof Uint8Array) {\n      header[\"Content-Length\"] = body.byteLength;\n    } else if (body instanceof Blob) {\n      header[\"Content-Length\"] = body.size;\n    }\n  }\n  outgoing.writeHead(status, header);\n  if (typeof body === \"string\" || body instanceof Uint8Array) {\n    outgoing.end(body);\n  } else if (body instanceof Blob) {\n    outgoing.end(new Uint8Array(await body.arrayBuffer()));\n  } else {\n    flushHeaders(outgoing);\n    await writeFromReadableStream(body, outgoing)?.catch(\n      (e) => handleResponseError(e, outgoing)\n    );\n  }\n  ;\n  outgoing[outgoingEnded]?.();\n};\nvar isPromise = (res) => typeof res.then === \"function\";\nvar responseViaResponseObject = async (res, outgoing, options = {}) => {\n  if (isPromise(res)) {\n    if (options.errorHandler) {\n      try {\n        res = await res;\n      } catch (err) {\n        const errRes = await options.errorHandler(err);\n        if (!errRes) {\n          return;\n        }\n        res = errRes;\n      }\n    } else {\n      res = await res.catch(handleFetchError);\n    }\n  }\n  if (cacheKey in res) {\n    return responseViaCache(res, outgoing);\n  }\n  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);\n  if (res.body) {\n    const reader = res.body.getReader();\n    const values = [];\n    let done = false;\n    let currentReadPromise = void 0;\n    if (resHeaderRecord[\"transfer-encoding\"] !== \"chunked\") {\n      let maxReadCount = 2;\n      for (let i = 0; i < maxReadCount; i++) {\n        currentReadPromise ||= reader.read();\n        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {\n          console.error(e);\n          done = true;\n        });\n        if (!chunk) {\n          if (i === 1) {\n            await new Promise((resolve) => setTimeout(resolve));\n            maxReadCount = 3;\n            continue;\n          }\n          break;\n        }\n        currentReadPromise = void 0;\n        if (chunk.value) {\n          values.push(chunk.value);\n        }\n        if (chunk.done) {\n          done = true;\n          break;\n        }\n      }\n      if (done && !(\"content-length\" in resHeaderRecord)) {\n        resHeaderRecord[\"content-length\"] = values.reduce((acc, value) => acc + value.length, 0);\n      }\n    }\n    outgoing.writeHead(res.status, resHeaderRecord);\n    values.forEach((value) => {\n      ;\n      outgoing.write(value);\n    });\n    if (done) {\n      outgoing.end();\n    } else {\n      if (values.length === 0) {\n        flushHeaders(outgoing);\n      }\n      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);\n    }\n  } else if (resHeaderRecord[X_ALREADY_SENT]) {\n  } else {\n    outgoing.writeHead(res.status, resHeaderRecord);\n    outgoing.end();\n  }\n  ;\n  outgoing[outgoingEnded]?.();\n};\nvar getRequestListener = (fetchCallback, options = {}) => {\n  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;\n  if (options.overrideGlobalObjects !== false && global.Request !== Request) {\n    Object.defineProperty(global, \"Request\", {\n      value: Request\n    });\n    Object.defineProperty(global, \"Response\", {\n      value: Response2\n    });\n  }\n  return async (incoming, outgoing) => {\n    let res, req;\n    try {\n      req = newRequest(incoming, options.hostname);\n      let incomingEnded = !autoCleanupIncoming || incoming.method === \"GET\" || incoming.method === \"HEAD\";\n      if (!incomingEnded) {\n        ;\n        incoming[wrapBodyStream] = true;\n        incoming.on(\"end\", () => {\n          incomingEnded = true;\n        });\n        if (incoming instanceof Http2ServerRequest2) {\n          ;\n          outgoing[outgoingEnded] = () => {\n            if (!incomingEnded) {\n              setTimeout(() => {\n                if (!incomingEnded) {\n                  setTimeout(() => {\n                    drainIncoming(incoming);\n                  });\n                }\n              });\n            }\n          };\n        }\n        outgoing.on(\"finish\", () => {\n          if (!incomingEnded) {\n            drainIncoming(incoming);\n          }\n        });\n      }\n      outgoing.on(\"close\", () => {\n        const abortController = req[abortControllerKey];\n        if (abortController) {\n          if (incoming.errored) {\n            req[abortControllerKey].abort(incoming.errored.toString());\n          } else if (!outgoing.writableFinished) {\n            req[abortControllerKey].abort(\"Client connection prematurely closed.\");\n          }\n        }\n        if (!incomingEnded) {\n          setTimeout(() => {\n            if (!incomingEnded) {\n              setTimeout(() => {\n                drainIncoming(incoming);\n              });\n            }\n          });\n        }\n      });\n      res = fetchCallback(req, { incoming, outgoing });\n      if (cacheKey in res) {\n        return responseViaCache(res, outgoing);\n      }\n    } catch (e) {\n      if (!res) {\n        if (options.errorHandler) {\n          res = await options.errorHandler(req ? e : toRequestError(e));\n          if (!res) {\n            return;\n          }\n        } else if (!req) {\n          res = handleRequestError();\n        } else {\n          res = handleFetchError(e);\n        }\n      } else {\n        return handleResponseError(e, outgoing);\n      }\n    }\n    try {\n      return await responseViaResponseObject(res, outgoing, options);\n    } catch (e) {\n      return handleResponseError(e, outgoing);\n    }\n  };\n};\n\n// src/server.ts\nvar createAdaptorServer = (options) => {\n  const fetchCallback = options.fetch;\n  const requestListener = getRequestListener(fetchCallback, {\n    hostname: options.hostname,\n    overrideGlobalObjects: options.overrideGlobalObjects,\n    autoCleanupIncoming: options.autoCleanupIncoming\n  });\n  const createServer = options.createServer || createServerHTTP;\n  const server = createServer(options.serverOptions || {}, requestListener);\n  return server;\n};\nvar serve = (options, listeningListener) => {\n  const server = createAdaptorServer(options);\n  server.listen(options?.port ?? 3e3, options.hostname, () => {\n    const serverInfo = server.address();\n    listeningListener && listeningListener(serverInfo);\n  });\n  return server;\n};\nexport {\n  RequestError,\n  createAdaptorServer,\n  getRequestListener,\n  serve\n};\n","/**\n * Web Standards Streamable HTTP Server Transport\n *\n * This is the core transport implementation using Web Standard APIs (Request, Response, ReadableStream).\n * It can run on any runtime that supports Web Standards: Node.js 18+, Cloudflare Workers, Deno, Bun, etc.\n *\n * For Node.js Express/HTTP compatibility, use `StreamableHTTPServerTransport` which wraps this transport.\n */\nimport { isInitializeRequest, isJSONRPCErrorResponse, isJSONRPCRequest, isJSONRPCResultResponse, JSONRPCMessageSchema, SUPPORTED_PROTOCOL_VERSIONS, DEFAULT_NEGOTIATED_PROTOCOL_VERSION } from '../types.js';\n/**\n * Server transport for Web Standards Streamable HTTP: this implements the MCP Streamable HTTP transport specification\n * using Web Standard APIs (Request, Response, ReadableStream).\n *\n * This transport works on any runtime that supports Web Standards: Node.js 18+, Cloudflare Workers, Deno, Bun, etc.\n *\n * Usage example:\n *\n * ```typescript\n * // Stateful mode - server sets the session ID\n * const statefulTransport = new WebStandardStreamableHTTPServerTransport({\n *   sessionIdGenerator: () => crypto.randomUUID(),\n * });\n *\n * // Stateless mode - explicitly set session ID to undefined\n * const statelessTransport = new WebStandardStreamableHTTPServerTransport({\n *   sessionIdGenerator: undefined,\n * });\n *\n * // Hono.js usage\n * app.all('/mcp', async (c) => {\n *   return transport.handleRequest(c.req.raw);\n * });\n *\n * // Cloudflare Workers usage\n * export default {\n *   async fetch(request: Request): Promise<Response> {\n *     return transport.handleRequest(request);\n *   }\n * };\n * ```\n *\n * In stateful mode:\n * - Session ID is generated and included in response headers\n * - Session ID is always included in initialization responses\n * - Requests with invalid session IDs are rejected with 404 Not Found\n * - Non-initialization requests without a session ID are rejected with 400 Bad Request\n * - State is maintained in-memory (connections, message history)\n *\n * In stateless mode:\n * - No Session ID is included in any responses\n * - No session validation is performed\n */\nexport class WebStandardStreamableHTTPServerTransport {\n    constructor(options = {}) {\n        this._started = false;\n        this._hasHandledRequest = false;\n        this._streamMapping = new Map();\n        this._requestToStreamMapping = new Map();\n        this._requestResponseMap = new Map();\n        this._initialized = false;\n        this._enableJsonResponse = false;\n        this._standaloneSseStreamId = '_GET_stream';\n        this.sessionIdGenerator = options.sessionIdGenerator;\n        this._enableJsonResponse = options.enableJsonResponse ?? false;\n        this._eventStore = options.eventStore;\n        this._onsessioninitialized = options.onsessioninitialized;\n        this._onsessionclosed = options.onsessionclosed;\n        this._allowedHosts = options.allowedHosts;\n        this._allowedOrigins = options.allowedOrigins;\n        this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;\n        this._retryInterval = options.retryInterval;\n    }\n    /**\n     * Starts the transport. This is required by the Transport interface but is a no-op\n     * for the Streamable HTTP transport as connections are managed per-request.\n     */\n    async start() {\n        if (this._started) {\n            throw new Error('Transport already started');\n        }\n        this._started = true;\n    }\n    /**\n     * Helper to create a JSON error response\n     */\n    createJsonErrorResponse(status, code, message, options) {\n        const error = { code, message };\n        if (options?.data !== undefined) {\n            error.data = options.data;\n        }\n        return new Response(JSON.stringify({\n            jsonrpc: '2.0',\n            error,\n            id: null\n        }), {\n            status,\n            headers: {\n                'Content-Type': 'application/json',\n                ...options?.headers\n            }\n        });\n    }\n    /**\n     * Validates request headers for DNS rebinding protection.\n     * @returns Error response if validation fails, undefined if validation passes.\n     */\n    validateRequestHeaders(req) {\n        // Skip validation if protection is not enabled\n        if (!this._enableDnsRebindingProtection) {\n            return undefined;\n        }\n        // Validate Host header if allowedHosts is configured\n        if (this._allowedHosts && this._allowedHosts.length > 0) {\n            const hostHeader = req.headers.get('host');\n            if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {\n                const error = `Invalid Host header: ${hostHeader}`;\n                this.onerror?.(new Error(error));\n                return this.createJsonErrorResponse(403, -32000, error);\n            }\n        }\n        // Validate Origin header if allowedOrigins is configured\n        if (this._allowedOrigins && this._allowedOrigins.length > 0) {\n            const originHeader = req.headers.get('origin');\n            if (originHeader && !this._allowedOrigins.includes(originHeader)) {\n                const error = `Invalid Origin header: ${originHeader}`;\n                this.onerror?.(new Error(error));\n                return this.createJsonErrorResponse(403, -32000, error);\n            }\n        }\n        return undefined;\n    }\n    /**\n     * Handles an incoming HTTP request, whether GET, POST, or DELETE\n     * Returns a Response object (Web Standard)\n     */\n    async handleRequest(req, options) {\n        // In stateless mode (no sessionIdGenerator), each request must use a fresh transport.\n        // Reusing a stateless transport causes message ID collisions between clients.\n        if (!this.sessionIdGenerator && this._hasHandledRequest) {\n            throw new Error('Stateless transport cannot be reused across requests. Create a new transport per request.');\n        }\n        this._hasHandledRequest = true;\n        // Validate request headers for DNS rebinding protection\n        const validationError = this.validateRequestHeaders(req);\n        if (validationError) {\n            return validationError;\n        }\n        switch (req.method) {\n            case 'POST':\n                return this.handlePostRequest(req, options);\n            case 'GET':\n                return this.handleGetRequest(req);\n            case 'DELETE':\n                return this.handleDeleteRequest(req);\n            default:\n                return this.handleUnsupportedRequest();\n        }\n    }\n    /**\n     * Writes a priming event to establish resumption capability.\n     * Only sends if eventStore is configured (opt-in for resumability) and\n     * the client's protocol version supports empty SSE data (>= 2025-11-25).\n     */\n    async writePrimingEvent(controller, encoder, streamId, protocolVersion) {\n        if (!this._eventStore) {\n            return;\n        }\n        // Priming events have empty data which older clients cannot handle.\n        // Only send priming events to clients with protocol version >= 2025-11-25\n        // which includes the fix for handling empty SSE data.\n        if (protocolVersion < '2025-11-25') {\n            return;\n        }\n        const primingEventId = await this._eventStore.storeEvent(streamId, {});\n        let primingEvent = `id: ${primingEventId}\\ndata: \\n\\n`;\n        if (this._retryInterval !== undefined) {\n            primingEvent = `id: ${primingEventId}\\nretry: ${this._retryInterval}\\ndata: \\n\\n`;\n        }\n        controller.enqueue(encoder.encode(primingEvent));\n    }\n    /**\n     * Handles GET requests for SSE stream\n     */\n    async handleGetRequest(req) {\n        // The client MUST include an Accept header, listing text/event-stream as a supported content type.\n        const acceptHeader = req.headers.get('accept');\n        if (!acceptHeader?.includes('text/event-stream')) {\n            this.onerror?.(new Error('Not Acceptable: Client must accept text/event-stream'));\n            return this.createJsonErrorResponse(406, -32000, 'Not Acceptable: Client must accept text/event-stream');\n        }\n        // If an Mcp-Session-Id is returned by the server during initialization,\n        // clients using the Streamable HTTP transport MUST include it\n        // in the Mcp-Session-Id header on all of their subsequent HTTP requests.\n        const sessionError = this.validateSession(req);\n        if (sessionError) {\n            return sessionError;\n        }\n        const protocolError = this.validateProtocolVersion(req);\n        if (protocolError) {\n            return protocolError;\n        }\n        // Handle resumability: check for Last-Event-ID header\n        if (this._eventStore) {\n            const lastEventId = req.headers.get('last-event-id');\n            if (lastEventId) {\n                return this.replayEvents(lastEventId);\n            }\n        }\n        // Check if there's already an active standalone SSE stream for this session\n        if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {\n            // Only one GET SSE stream is allowed per session\n            this.onerror?.(new Error('Conflict: Only one SSE stream is allowed per session'));\n            return this.createJsonErrorResponse(409, -32000, 'Conflict: Only one SSE stream is allowed per session');\n        }\n        const encoder = new TextEncoder();\n        let streamController;\n        // Create a ReadableStream with a controller we can use to push SSE events\n        const readable = new ReadableStream({\n            start: controller => {\n                streamController = controller;\n            },\n            cancel: () => {\n                // Stream was cancelled by client\n                this._streamMapping.delete(this._standaloneSseStreamId);\n            }\n        });\n        const headers = {\n            'Content-Type': 'text/event-stream',\n            'Cache-Control': 'no-cache, no-transform',\n            Connection: 'keep-alive'\n        };\n        // After initialization, always include the session ID if we have one\n        if (this.sessionId !== undefined) {\n            headers['mcp-session-id'] = this.sessionId;\n        }\n        // Store the stream mapping with the controller for pushing data\n        this._streamMapping.set(this._standaloneSseStreamId, {\n            controller: streamController,\n            encoder,\n            cleanup: () => {\n                this._streamMapping.delete(this._standaloneSseStreamId);\n                try {\n                    streamController.close();\n                }\n                catch {\n                    // Controller might already be closed\n                }\n            }\n        });\n        return new Response(readable, { headers });\n    }\n    /**\n     * Replays events that would have been sent after the specified event ID\n     * Only used when resumability is enabled\n     */\n    async replayEvents(lastEventId) {\n        if (!this._eventStore) {\n            this.onerror?.(new Error('Event store not configured'));\n            return this.createJsonErrorResponse(400, -32000, 'Event store not configured');\n        }\n        try {\n            // If getStreamIdForEventId is available, use it for conflict checking\n            let streamId;\n            if (this._eventStore.getStreamIdForEventId) {\n                streamId = await this._eventStore.getStreamIdForEventId(lastEventId);\n                if (!streamId) {\n                    this.onerror?.(new Error('Invalid event ID format'));\n                    return this.createJsonErrorResponse(400, -32000, 'Invalid event ID format');\n                }\n                // Check conflict with the SAME streamId we'll use for mapping\n                if (this._streamMapping.get(streamId) !== undefined) {\n                    this.onerror?.(new Error('Conflict: Stream already has an active connection'));\n                    return this.createJsonErrorResponse(409, -32000, 'Conflict: Stream already has an active connection');\n                }\n            }\n            const headers = {\n                'Content-Type': 'text/event-stream',\n                'Cache-Control': 'no-cache, no-transform',\n                Connection: 'keep-alive'\n            };\n            if (this.sessionId !== undefined) {\n                headers['mcp-session-id'] = this.sessionId;\n            }\n            // Create a ReadableStream with controller for SSE\n            const encoder = new TextEncoder();\n            let streamController;\n            const readable = new ReadableStream({\n                start: controller => {\n                    streamController = controller;\n                },\n                cancel: () => {\n                    // Stream was cancelled by client\n                    // Cleanup will be handled by the mapping\n                }\n            });\n            // Replay events - returns the streamId for backwards compatibility\n            const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {\n                send: async (eventId, message) => {\n                    const success = this.writeSSEEvent(streamController, encoder, message, eventId);\n                    if (!success) {\n                        this.onerror?.(new Error('Failed replay events'));\n                        try {\n                            streamController.close();\n                        }\n                        catch {\n                            // Controller might already be closed\n                        }\n                    }\n                }\n            });\n            this._streamMapping.set(replayedStreamId, {\n                controller: streamController,\n                encoder,\n                cleanup: () => {\n                    this._streamMapping.delete(replayedStreamId);\n                    try {\n                        streamController.close();\n                    }\n                    catch {\n                        // Controller might already be closed\n                    }\n                }\n            });\n            return new Response(readable, { headers });\n        }\n        catch (error) {\n            this.onerror?.(error);\n            return this.createJsonErrorResponse(500, -32000, 'Error replaying events');\n        }\n    }\n    /**\n     * Writes an event to an SSE stream via controller with proper formatting\n     */\n    writeSSEEvent(controller, encoder, message, eventId) {\n        try {\n            let eventData = `event: message\\n`;\n            // Include event ID if provided - this is important for resumability\n            if (eventId) {\n                eventData += `id: ${eventId}\\n`;\n            }\n            eventData += `data: ${JSON.stringify(message)}\\n\\n`;\n            controller.enqueue(encoder.encode(eventData));\n            return true;\n        }\n        catch (error) {\n            this.onerror?.(error);\n            return false;\n        }\n    }\n    /**\n     * Handles unsupported requests (PUT, PATCH, etc.)\n     */\n    handleUnsupportedRequest() {\n        this.onerror?.(new Error('Method not allowed.'));\n        return new Response(JSON.stringify({\n            jsonrpc: '2.0',\n            error: {\n                code: -32000,\n                message: 'Method not allowed.'\n            },\n            id: null\n        }), {\n            status: 405,\n            headers: {\n                Allow: 'GET, POST, DELETE',\n                'Content-Type': 'application/json'\n            }\n        });\n    }\n    /**\n     * Handles POST requests containing JSON-RPC messages\n     */\n    async handlePostRequest(req, options) {\n        try {\n            // Validate the Accept header\n            const acceptHeader = req.headers.get('accept');\n            // The client MUST include an Accept header, listing both application/json and text/event-stream as supported content types.\n            if (!acceptHeader?.includes('application/json') || !acceptHeader.includes('text/event-stream')) {\n                this.onerror?.(new Error('Not Acceptable: Client must accept both application/json and text/event-stream'));\n                return this.createJsonErrorResponse(406, -32000, 'Not Acceptable: Client must accept both application/json and text/event-stream');\n            }\n            const ct = req.headers.get('content-type');\n            if (!ct || !ct.includes('application/json')) {\n                this.onerror?.(new Error('Unsupported Media Type: Content-Type must be application/json'));\n                return this.createJsonErrorResponse(415, -32000, 'Unsupported Media Type: Content-Type must be application/json');\n            }\n            // Build request info from headers and URL\n            const requestInfo = {\n                headers: Object.fromEntries(req.headers.entries()),\n                url: new URL(req.url)\n            };\n            let rawMessage;\n            if (options?.parsedBody !== undefined) {\n                rawMessage = options.parsedBody;\n            }\n            else {\n                try {\n                    rawMessage = await req.json();\n                }\n                catch {\n                    this.onerror?.(new Error('Parse error: Invalid JSON'));\n                    return this.createJsonErrorResponse(400, -32700, 'Parse error: Invalid JSON');\n                }\n            }\n            let messages;\n            // handle batch and single messages\n            try {\n                if (Array.isArray(rawMessage)) {\n                    messages = rawMessage.map(msg => JSONRPCMessageSchema.parse(msg));\n                }\n                else {\n                    messages = [JSONRPCMessageSchema.parse(rawMessage)];\n                }\n            }\n            catch {\n                this.onerror?.(new Error('Parse error: Invalid JSON-RPC message'));\n                return this.createJsonErrorResponse(400, -32700, 'Parse error: Invalid JSON-RPC message');\n            }\n            // Check if this is an initialization request\n            // https://spec.modelcontextprotocol.io/specification/2025-03-26/basic/lifecycle/\n            const isInitializationRequest = messages.some(isInitializeRequest);\n            if (isInitializationRequest) {\n                // If it's a server with session management and the session ID is already set we should reject the request\n                // to avoid re-initialization.\n                if (this._initialized && this.sessionId !== undefined) {\n                    this.onerror?.(new Error('Invalid Request: Server already initialized'));\n                    return this.createJsonErrorResponse(400, -32600, 'Invalid Request: Server already initialized');\n                }\n                if (messages.length > 1) {\n                    this.onerror?.(new Error('Invalid Request: Only one initialization request is allowed'));\n                    return this.createJsonErrorResponse(400, -32600, 'Invalid Request: Only one initialization request is allowed');\n                }\n                this.sessionId = this.sessionIdGenerator?.();\n                this._initialized = true;\n                // If we have a session ID and an onsessioninitialized handler, call it immediately\n                // This is needed in cases where the server needs to keep track of multiple sessions\n                if (this.sessionId && this._onsessioninitialized) {\n                    await Promise.resolve(this._onsessioninitialized(this.sessionId));\n                }\n            }\n            if (!isInitializationRequest) {\n                // If an Mcp-Session-Id is returned by the server during initialization,\n                // clients using the Streamable HTTP transport MUST include it\n                // in the Mcp-Session-Id header on all of their subsequent HTTP requests.\n                const sessionError = this.validateSession(req);\n                if (sessionError) {\n                    return sessionError;\n                }\n                // Mcp-Protocol-Version header is required for all requests after initialization.\n                const protocolError = this.validateProtocolVersion(req);\n                if (protocolError) {\n                    return protocolError;\n                }\n            }\n            // check if it contains requests\n            const hasRequests = messages.some(isJSONRPCRequest);\n            if (!hasRequests) {\n                // if it only contains notifications or responses, return 202\n                for (const message of messages) {\n                    this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });\n                }\n                return new Response(null, { status: 202 });\n            }\n            // The default behavior is to use SSE streaming\n            // but in some cases server will return JSON responses\n            const streamId = crypto.randomUUID();\n            // Extract protocol version for priming event decision.\n            // For initialize requests, get from request params.\n            // For other requests, get from header (already validated).\n            const initRequest = messages.find(m => isInitializeRequest(m));\n            const clientProtocolVersion = initRequest\n                ? initRequest.params.protocolVersion\n                : (req.headers.get('mcp-protocol-version') ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION);\n            if (this._enableJsonResponse) {\n                // For JSON response mode, return a Promise that resolves when all responses are ready\n                return new Promise(resolve => {\n                    this._streamMapping.set(streamId, {\n                        resolveJson: resolve,\n                        cleanup: () => {\n                            this._streamMapping.delete(streamId);\n                        }\n                    });\n                    for (const message of messages) {\n                        if (isJSONRPCRequest(message)) {\n                            this._requestToStreamMapping.set(message.id, streamId);\n                        }\n                    }\n                    for (const message of messages) {\n                        this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });\n                    }\n                });\n            }\n            // SSE streaming mode - use ReadableStream with controller for more reliable data pushing\n            const encoder = new TextEncoder();\n            let streamController;\n            const readable = new ReadableStream({\n                start: controller => {\n                    streamController = controller;\n                },\n                cancel: () => {\n                    // Stream was cancelled by client\n                    this._streamMapping.delete(streamId);\n                }\n            });\n            const headers = {\n                'Content-Type': 'text/event-stream',\n                'Cache-Control': 'no-cache',\n                Connection: 'keep-alive'\n            };\n            // After initialization, always include the session ID if we have one\n            if (this.sessionId !== undefined) {\n                headers['mcp-session-id'] = this.sessionId;\n            }\n            // Store the response for this request to send messages back through this connection\n            // We need to track by request ID to maintain the connection\n            for (const message of messages) {\n                if (isJSONRPCRequest(message)) {\n                    this._streamMapping.set(streamId, {\n                        controller: streamController,\n                        encoder,\n                        cleanup: () => {\n                            this._streamMapping.delete(streamId);\n                            try {\n                                streamController.close();\n                            }\n                            catch {\n                                // Controller might already be closed\n                            }\n                        }\n                    });\n                    this._requestToStreamMapping.set(message.id, streamId);\n                }\n            }\n            // Write priming event if event store is configured (after mapping is set up)\n            await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);\n            // handle each message\n            for (const message of messages) {\n                // Build closeSSEStream callback for requests when eventStore is configured\n                // AND client supports resumability (protocol version >= 2025-11-25).\n                // Old clients can't resume if the stream is closed early because they\n                // didn't receive a priming event with an event ID.\n                let closeSSEStream;\n                let closeStandaloneSSEStream;\n                if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= '2025-11-25') {\n                    closeSSEStream = () => {\n                        this.closeSSEStream(message.id);\n                    };\n                    closeStandaloneSSEStream = () => {\n                        this.closeStandaloneSSEStream();\n                    };\n                }\n                this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });\n            }\n            // The server SHOULD NOT close the SSE stream before sending all JSON-RPC responses\n            // This will be handled by the send() method when responses are ready\n            return new Response(readable, { status: 200, headers });\n        }\n        catch (error) {\n            // return JSON-RPC formatted error\n            this.onerror?.(error);\n            return this.createJsonErrorResponse(400, -32700, 'Parse error', { data: String(error) });\n        }\n    }\n    /**\n     * Handles DELETE requests to terminate sessions\n     */\n    async handleDeleteRequest(req) {\n        const sessionError = this.validateSession(req);\n        if (sessionError) {\n            return sessionError;\n        }\n        const protocolError = this.validateProtocolVersion(req);\n        if (protocolError) {\n            return protocolError;\n        }\n        await Promise.resolve(this._onsessionclosed?.(this.sessionId));\n        await this.close();\n        return new Response(null, { status: 200 });\n    }\n    /**\n     * Validates session ID for non-initialization requests.\n     * Returns Response error if invalid, undefined otherwise\n     */\n    validateSession(req) {\n        if (this.sessionIdGenerator === undefined) {\n            // If the sessionIdGenerator ID is not set, the session management is disabled\n            // and we don't need to validate the session ID\n            return undefined;\n        }\n        if (!this._initialized) {\n            // If the server has not been initialized yet, reject all requests\n            this.onerror?.(new Error('Bad Request: Server not initialized'));\n            return this.createJsonErrorResponse(400, -32000, 'Bad Request: Server not initialized');\n        }\n        const sessionId = req.headers.get('mcp-session-id');\n        if (!sessionId) {\n            // Non-initialization requests without a session ID should return 400 Bad Request\n            this.onerror?.(new Error('Bad Request: Mcp-Session-Id header is required'));\n            return this.createJsonErrorResponse(400, -32000, 'Bad Request: Mcp-Session-Id header is required');\n        }\n        if (sessionId !== this.sessionId) {\n            // Reject requests with invalid session ID with 404 Not Found\n            this.onerror?.(new Error('Session not found'));\n            return this.createJsonErrorResponse(404, -32001, 'Session not found');\n        }\n        return undefined;\n    }\n    /**\n     * Validates the MCP-Protocol-Version header on incoming requests.\n     *\n     * For initialization: Version negotiation handles unknown versions gracefully\n     * (server responds with its supported version).\n     *\n     * For subsequent requests with MCP-Protocol-Version header:\n     * - Accept if in supported list\n     * - 400 if unsupported\n     *\n     * For HTTP requests without the MCP-Protocol-Version header:\n     * - Accept and default to the version negotiated at initialization\n     */\n    validateProtocolVersion(req) {\n        const protocolVersion = req.headers.get('mcp-protocol-version');\n        if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {\n            this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion}` +\n                ` (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(', ')})`));\n            return this.createJsonErrorResponse(400, -32000, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(', ')})`);\n        }\n        return undefined;\n    }\n    async close() {\n        // Close all SSE connections\n        this._streamMapping.forEach(({ cleanup }) => {\n            cleanup();\n        });\n        this._streamMapping.clear();\n        // Clear any pending responses\n        this._requestResponseMap.clear();\n        this.onclose?.();\n    }\n    /**\n     * Close an SSE stream for a specific request, triggering client reconnection.\n     * Use this to implement polling behavior during long-running operations -\n     * client will reconnect after the retry interval specified in the priming event.\n     */\n    closeSSEStream(requestId) {\n        const streamId = this._requestToStreamMapping.get(requestId);\n        if (!streamId)\n            return;\n        const stream = this._streamMapping.get(streamId);\n        if (stream) {\n            stream.cleanup();\n        }\n    }\n    /**\n     * Close the standalone GET SSE stream, triggering client reconnection.\n     * Use this to implement polling behavior for server-initiated notifications.\n     */\n    closeStandaloneSSEStream() {\n        const stream = this._streamMapping.get(this._standaloneSseStreamId);\n        if (stream) {\n            stream.cleanup();\n        }\n    }\n    async send(message, options) {\n        let requestId = options?.relatedRequestId;\n        if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {\n            // If the message is a response, use the request ID from the message\n            requestId = message.id;\n        }\n        // Check if this message should be sent on the standalone SSE stream (no request ID)\n        // Ignore notifications from tools (which have relatedRequestId set)\n        // Those will be sent via dedicated response SSE streams\n        if (requestId === undefined) {\n            // For standalone SSE streams, we can only send requests and notifications\n            if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {\n                throw new Error('Cannot send a response on a standalone SSE stream unless resuming a previous client request');\n            }\n            // Generate and store event ID if event store is provided\n            // Store even if stream is disconnected so events can be replayed on reconnect\n            let eventId;\n            if (this._eventStore) {\n                // Stores the event and gets the generated event ID\n                eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);\n            }\n            const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);\n            if (standaloneSse === undefined) {\n                // Stream is disconnected - event is stored for replay, nothing more to do\n                return;\n            }\n            // Send the message to the standalone SSE stream\n            if (standaloneSse.controller && standaloneSse.encoder) {\n                this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);\n            }\n            return;\n        }\n        // Get the response for this request\n        const streamId = this._requestToStreamMapping.get(requestId);\n        if (!streamId) {\n            throw new Error(`No connection established for request ID: ${String(requestId)}`);\n        }\n        const stream = this._streamMapping.get(streamId);\n        if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {\n            // For SSE responses, generate event ID if event store is provided\n            let eventId;\n            if (this._eventStore) {\n                eventId = await this._eventStore.storeEvent(streamId, message);\n            }\n            // Write the event to the response stream\n            this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);\n        }\n        if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {\n            this._requestResponseMap.set(requestId, message);\n            const relatedIds = Array.from(this._requestToStreamMapping.entries())\n                .filter(([_, sid]) => sid === streamId)\n                .map(([id]) => id);\n            // Check if we have responses for all requests using this connection\n            const allResponsesReady = relatedIds.every(id => this._requestResponseMap.has(id));\n            if (allResponsesReady) {\n                if (!stream) {\n                    throw new Error(`No connection established for request ID: ${String(requestId)}`);\n                }\n                if (this._enableJsonResponse && stream.resolveJson) {\n                    // All responses ready, send as JSON\n                    const headers = {\n                        'Content-Type': 'application/json'\n                    };\n                    if (this.sessionId !== undefined) {\n                        headers['mcp-session-id'] = this.sessionId;\n                    }\n                    const responses = relatedIds.map(id => this._requestResponseMap.get(id));\n                    if (responses.length === 1) {\n                        stream.resolveJson(new Response(JSON.stringify(responses[0]), { status: 200, headers }));\n                    }\n                    else {\n                        stream.resolveJson(new Response(JSON.stringify(responses), { status: 200, headers }));\n                    }\n                }\n                else {\n                    // End the SSE stream\n                    stream.cleanup();\n                }\n                // Clean up\n                for (const id of relatedIds) {\n                    this._requestResponseMap.delete(id);\n                    this._requestToStreamMapping.delete(id);\n                }\n            }\n        }\n    }\n}\n//# sourceMappingURL=webStandardStreamableHttp.js.map","/**\n * Node.js HTTP Streamable HTTP Server Transport\n *\n * This is a thin wrapper around `WebStandardStreamableHTTPServerTransport` that provides\n * compatibility with Node.js HTTP server (IncomingMessage/ServerResponse).\n *\n * For web-standard environments (Cloudflare Workers, Deno, Bun), use `WebStandardStreamableHTTPServerTransport` directly.\n */\nimport { getRequestListener } from '@hono/node-server';\nimport { WebStandardStreamableHTTPServerTransport } from './webStandardStreamableHttp.js';\n/**\n * Server transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.\n * It supports both SSE streaming and direct HTTP responses.\n *\n * This is a wrapper around `WebStandardStreamableHTTPServerTransport` that provides Node.js HTTP compatibility.\n * It uses the `@hono/node-server` library to convert between Node.js HTTP and Web Standard APIs.\n *\n * Usage example:\n *\n * ```typescript\n * // Stateful mode - server sets the session ID\n * const statefulTransport = new StreamableHTTPServerTransport({\n *   sessionIdGenerator: () => randomUUID(),\n * });\n *\n * // Stateless mode - explicitly set session ID to undefined\n * const statelessTransport = new StreamableHTTPServerTransport({\n *   sessionIdGenerator: undefined,\n * });\n *\n * // Using with pre-parsed request body\n * app.post('/mcp', (req, res) => {\n *   transport.handleRequest(req, res, req.body);\n * });\n * ```\n *\n * In stateful mode:\n * - Session ID is generated and included in response headers\n * - Session ID is always included in initialization responses\n * - Requests with invalid session IDs are rejected with 404 Not Found\n * - Non-initialization requests without a session ID are rejected with 400 Bad Request\n * - State is maintained in-memory (connections, message history)\n *\n * In stateless mode:\n * - No Session ID is included in any responses\n * - No session validation is performed\n */\nexport class StreamableHTTPServerTransport {\n    constructor(options = {}) {\n        // Store auth and parsedBody per request for passing through to handleRequest\n        this._requestContext = new WeakMap();\n        this._webStandardTransport = new WebStandardStreamableHTTPServerTransport(options);\n        // Create a request listener that wraps the web standard transport\n        // getRequestListener converts Node.js HTTP to Web Standard and properly handles SSE streaming\n        // overrideGlobalObjects: false prevents Hono from overwriting global Response, which would\n        // break frameworks like Next.js whose response classes extend the native Response\n        this._requestListener = getRequestListener(async (webRequest) => {\n            // Get context if available (set during handleRequest)\n            const context = this._requestContext.get(webRequest);\n            return this._webStandardTransport.handleRequest(webRequest, {\n                authInfo: context?.authInfo,\n                parsedBody: context?.parsedBody\n            });\n        }, { overrideGlobalObjects: false });\n    }\n    /**\n     * Gets the session ID for this transport instance.\n     */\n    get sessionId() {\n        return this._webStandardTransport.sessionId;\n    }\n    /**\n     * Sets callback for when the transport is closed.\n     */\n    set onclose(handler) {\n        this._webStandardTransport.onclose = handler;\n    }\n    get onclose() {\n        return this._webStandardTransport.onclose;\n    }\n    /**\n     * Sets callback for transport errors.\n     */\n    set onerror(handler) {\n        this._webStandardTransport.onerror = handler;\n    }\n    get onerror() {\n        return this._webStandardTransport.onerror;\n    }\n    /**\n     * Sets callback for incoming messages.\n     */\n    set onmessage(handler) {\n        this._webStandardTransport.onmessage = handler;\n    }\n    get onmessage() {\n        return this._webStandardTransport.onmessage;\n    }\n    /**\n     * Starts the transport. This is required by the Transport interface but is a no-op\n     * for the Streamable HTTP transport as connections are managed per-request.\n     */\n    async start() {\n        return this._webStandardTransport.start();\n    }\n    /**\n     * Closes the transport and all active connections.\n     */\n    async close() {\n        return this._webStandardTransport.close();\n    }\n    /**\n     * Sends a JSON-RPC message through the transport.\n     */\n    async send(message, options) {\n        return this._webStandardTransport.send(message, options);\n    }\n    /**\n     * Handles an incoming HTTP request, whether GET or POST.\n     *\n     * This method converts Node.js HTTP objects to Web Standard Request/Response\n     * and delegates to the underlying WebStandardStreamableHTTPServerTransport.\n     *\n     * @param req - Node.js IncomingMessage, optionally with auth property from middleware\n     * @param res - Node.js ServerResponse\n     * @param parsedBody - Optional pre-parsed body from body-parser middleware\n     */\n    async handleRequest(req, res, parsedBody) {\n        // Store context for this request to pass through auth and parsedBody\n        // We need to intercept the request creation to attach this context\n        const authInfo = req.auth;\n        // Create a custom handler that includes our context\n        // overrideGlobalObjects: false prevents Hono from overwriting global Response, which would\n        // break frameworks like Next.js whose response classes extend the native Response\n        const handler = getRequestListener(async (webRequest) => {\n            return this._webStandardTransport.handleRequest(webRequest, {\n                authInfo,\n                parsedBody\n            });\n        }, { overrideGlobalObjects: false });\n        // Delegate to the request listener which handles all the Node.js <-> Web Standard conversion\n        // including proper SSE streaming support\n        await handler(req, res);\n    }\n    /**\n     * Close an SSE stream for a specific request, triggering client reconnection.\n     * Use this to implement polling behavior during long-running operations -\n     * client will reconnect after the retry interval specified in the priming event.\n     */\n    closeSSEStream(requestId) {\n        this._webStandardTransport.closeSSEStream(requestId);\n    }\n    /**\n     * Close the standalone GET SSE stream, triggering client reconnection.\n     * Use this to implement polling behavior for server-initiated notifications.\n     */\n    closeStandaloneSSEStream() {\n        this._webStandardTransport.closeStandaloneSSEStream();\n    }\n}\n//# sourceMappingURL=streamableHttp.js.map","/**\n * The wrapper's local HTTP MCP server — real-tool bridging plus the actual enforcement of which\n * bridged tools are callable. Wrapper-only — never imported by `adapter.ts`.\n *\n * @remarks\n * Built on the LOW-LEVEL `Server` class from `@modelcontextprotocol/sdk/server`, never\n * `McpServer.registerTool()` (which requires Zod-shaped schemas — incompatible with ADK's\n * Joi-based tools, already rendered to plain JSON Schema by the adapter before this module ever\n * sees them). The low-level `Server` takes MCP *protocol* schemas (`ListToolsRequestSchema`/\n * `CallToolRequestSchema`), not per-tool argument schemas, so no Zod object is authored anywhere\n * in this file — the only Zod footprint is the two pre-built protocol-schema tokens imported from\n * the SDK itself.\n *\n * `--allowedTools` is kept in the CLI invocation only as a defense-in-depth, human-readable\n * statement of intent (see `wrapper.ts`'s argv construction) — it CANNOT be the real enforcement\n * mechanism, because `--dangerously-skip-permissions` removes the permission engine that an\n * allow-RULE feeds. The real enforcement happens here, twice over: `bridgedTools` arrives from the\n * adapter already pre-filtered to exclude `disallowedTools`, so a disallowed name is never even\n * listed; and the `CallTool` handler independently re-checks the requested name against that same\n * already-filtered list before ever emitting a `tool_call_request` to the adapter.\n */\n\nimport { randomUUID } from 'node:crypto'\nimport { createServer as createHttpServer } from 'node:http'\nimport { Server } from '@modelcontextprotocol/sdk/server/index.js'\nimport { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'\nimport { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'\nimport type { WrapperBridgedTool } from './wire'\nimport type { Server as HttpServer } from 'node:http'\n\n/** A pending `CallTool` request awaiting a `tool_call_response` from the adapter. */\ninterface PendingCall {\n  resolve: (result: { content: Array<Record<string, unknown>>; isError?: boolean }) => void\n}\n\n/** The running bridge: its bound port, and hooks to route calls to/from the adapter side. */\nexport interface McpBridge {\n  /** The ephemeral loopback port the bridge is listening on. */\n  port: number\n  /**\n   * Replaces the bridge's advertised tool set. The bridge starts with an EMPTY set at boot (so it\n   * can bind its port and let the wrapper emit `ready` before a `run` command — carrying the real\n   * tool list — has arrived); `wrapper.ts` calls this once, when `run` arrives, before spawning\n   * `claude`.\n   */\n  setBridgedTools(tools: WrapperBridgedTool[]): void\n  /**\n   * Called by `wrapper.ts` when a `tool_call_response` command arrives from the adapter, to\n   * settle the matching pending `CallTool` request.\n   */\n  resolveToolCall(\n    requestId: string,\n    result: { content: Array<Record<string, unknown>>; isError?: boolean }\n  ): void\n  /**\n   * Reject every still-pending `CallTool` request with an `isError: true` result explaining the\n   * bridge is shutting down. Must run BEFORE `close()` — an in-flight request is itself an active\n   * HTTP connection, so settling it first is what lets `close()` (and the underlying `http.Server`\n   * close callback) unblock.\n   */\n  rejectPending(reason: string): void\n  /** Closes the MCP transport — this is what actually tears down any open SSE stream via its own `cleanup()` calls. Must run AFTER `rejectPending()` and BEFORE the HTTP listener is closed. */\n  closeTransport(): Promise<void>\n  /** Closes the HTTP listener. Callback-based under the hood — promisified here. Must run LAST. */\n  closeHttpServer(): Promise<void>\n}\n\n/**\n * Start the bridge: bind an ephemeral loopback HTTP listener, wire a `StreamableHTTPServerTransport`\n * (session-scoped to this one wrapper-lifetime connection — see the `sessionIdGenerator` remark\n * below) to a low-level `Server` constructed with the explicit `tools` capability (required — the\n * SDK throws for `tools/list`/`tools/call` otherwise), and register the two handlers that make the\n * current `bridgedTools` set reachable over MCP.\n *\n * @remarks\n * Starts with an EMPTY tool set — the bridge must bind its port and let the wrapper emit `ready`\n * BEFORE the adapter has sent a `run` command carrying the real tool list (the adapter waits for\n * `ready` before sending `run`, so starting the bridge only after `run` arrives would deadlock\n * both sides). Call {@link McpBridge.setBridgedTools} once `run` arrives, before spawning `claude`.\n *\n * @param onToolCallRequest - Called with `(requestId, toolName, args)` for every `CallTool` the\n *   bridge accepts; the caller (`wrapper.ts`) forwards this as a `tool_call_request` `WrapperEvent`\n *   to the adapter and eventually calls `resolveToolCall` with the adapter's answer.\n */\nexport const startMcpBridge = async (\n  onToolCallRequest: (requestId: string, toolName: string, args: unknown) => void\n): Promise<McpBridge> => {\n  const pending = new Map<string, PendingCall>()\n  let nextRequestId = 0\n  let bridgedTools: WrapperBridgedTool[] = []\n\n  const server = new Server({ name: 'adk_bridge', version: '1' }, { capabilities: { tools: {} } })\n\n  server.setRequestHandler(ListToolsRequestSchema, () => ({\n    tools: bridgedTools.map((t) => ({\n      name: t.name,\n      description: t.description,\n      inputSchema: t.inputSchema,\n    })),\n  }))\n\n  server.setRequestHandler(CallToolRequestSchema, async (request) => {\n    const name = request.params.name\n    if (!bridgedTools.some((t) => t.name === name)) {\n      // Defense-in-depth: this should be unreachable in practice, since `bridgedTools` was\n      // already filtered by the adapter before it ever reached this process — but re-check\n      // anyway rather than trusting that invariant blindly.\n      return {\n        content: [{ type: 'text', text: `Tool \"${name}\" is not available in this session.` }],\n        isError: true,\n      }\n    }\n    const requestId = String(nextRequestId++)\n    const result = await new Promise<{\n      content: Array<Record<string, unknown>>\n      isError?: boolean\n    }>((resolve) => {\n      pending.set(requestId, { resolve })\n      onToolCallRequest(requestId, name, request.params.arguments)\n    })\n    return result\n  })\n\n  // NOT `sessionIdGenerator: undefined` (\"stateless\" mode). Confirmed directly against the\n  // installed SDK (@modelcontextprotocol/sdk@1.29.0): `WebStandardStreamableHTTPServerTransport`\n  // throws \"Stateless transport cannot be reused across requests. Create a new transport per\n  // request.\" on the SECOND request a stateless transport ever handles (source:\n  // server/webStandardStreamableHttp.js's `_hasHandledRequest` guard in `handleRequest`) — every\n  // `ListTools`/`CallTool` after the very first over the bridge's lifetime would 500. A single\n  // wrapper-lifetime session id (scoped to one dispatch iteration, discarded with the process) is\n  // what \"stateless across DISPATCHES\" (Decision D) actually requires here, not a stateless\n  // transport in the SDK's own sense.\n  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() })\n\n  // Settling a pending call (`resolveToolCall`/`rejectPending`'s `entry.resolve(...)`, below) only\n  // unblocks the SDK's OWN internal handler-completion Promise — the actual `transport.send()` call\n  // that flushes the JSON-RPC response over the wire happens several microtask turns later, inside\n  // the SDK's own `.then(handler).then(send)` chain (`shared/protocol.js`'s `_onrequest`). Confirmed\n  // by direct reproduction: calling `closeTransport()` immediately after `rejectPending()` (no gap)\n  // silently drops the very response `rejectPending()` just produced — the caller's `CallTool`\n  // promise then never settles. Wrapping `send` here to track every in-flight call is what lets\n  // `closeTransport()` (below) drain them first, a real fix rather than a fixed-delay guess.\n  const inFlightSends = new Set<Promise<unknown>>()\n  const originalSend = transport.send.bind(transport)\n  transport.send = ((...args: Parameters<typeof originalSend>) => {\n    const sent = originalSend(...args)\n    inFlightSends.add(sent)\n    void sent.finally(() => inFlightSends.delete(sent))\n    return sent\n  }) as typeof transport.send\n\n  await server.connect(transport)\n\n  const httpServer: HttpServer = createHttpServer((req, res) => {\n    void transport.handleRequest(req, res)\n  })\n\n  const port = await new Promise<number>((resolve, reject) => {\n    httpServer.once('error', reject)\n    httpServer.listen(0, '127.0.0.1', () => {\n      const address = httpServer.address()\n      if (address === null || typeof address === 'string') {\n        reject(new Error('MCP bridge HTTP listener did not bind to a port'))\n        return\n      }\n      resolve(address.port)\n    })\n  })\n\n  return {\n    port,\n    setBridgedTools(tools) {\n      bridgedTools = tools\n    },\n    resolveToolCall(requestId, result) {\n      const entry = pending.get(requestId)\n      if (!entry) return\n      pending.delete(requestId)\n      entry.resolve(result)\n    },\n    rejectPending(reason) {\n      for (const [requestId, entry] of pending) {\n        pending.delete(requestId)\n        entry.resolve({ content: [{ type: 'text', text: reason }], isError: true })\n      }\n    },\n    async closeTransport() {\n      // A call `resolveToolCall`/`rejectPending` just settled has NOT yet reached\n      // `transport.send()` at the instant those methods return — the SDK's own handler-completion\n      // chain needs at least one more event-loop turn to get there (see the `inFlightSends`\n      // remark above), so `inFlightSends` can still be empty here even though a send is about to\n      // start. Yield one turn first, then drain whatever is actually in flight, repeating briefly\n      // in case draining itself lets a further queued send begin — bounded so a genuinely stuck\n      // send can't hang shutdown forever.\n      await new Promise<void>((resolve) => setImmediate(resolve))\n      for (let i = 0; i < 5; i++) {\n        const snapshot = Array.from(inFlightSends)\n        if (snapshot.length === 0) break\n        await Promise.allSettled(snapshot)\n      }\n      await transport.close()\n    },\n    async closeHttpServer() {\n      await new Promise<void>((resolve, reject) => {\n        httpServer.close((err) => (err ? reject(err) : resolve()))\n      })\n    },\n  }\n}\n","/**\n * Claude Code CLI's own stream-json vocabulary types and parser. Wrapper-only — never imported by\n * `adapter.ts`.\n *\n * @remarks\n * No `@nhtio/adk/*` imports (this module runs inside the wrapper process, per Decision A/C — the\n * wrapper is self-contained with respect to the ADK). Parses the `--output-format stream-json`\n * NDJSON lines `claude` emits into a small internal shape `wrapper.ts` then translates into the\n * normalized `WrapperEvent` union from `./wire`.\n *\n * The vocabulary here converges across the official docs and two independent prior-art parsers\n * (`nhtio-agent-delegator`'s `claude_harness.ts`, `giveon-claude-max-api-proxy`'s `manager.ts`):\n * `system` (init/api_retry subtypes), `assistant`/`user` (with `parent_tool_use_id` distinguishing\n * main-conversation from subagent text), `stream_event` (partial message deltas), and a terminal\n * `result` (success/error).\n */\n\n/** A `system` event — either the one-time init handshake or a mid-turn retry notice. */\nexport interface ClaudeSystemInitLine {\n  type: 'system'\n  subtype: 'init'\n  model?: string\n  tools?: string[]\n  mcp_servers?: Array<{ name: string; status?: string }>\n  [key: string]: unknown\n}\n\nexport interface ClaudeSystemApiRetryLine {\n  type: 'system'\n  subtype: 'api_retry'\n  attempt?: number\n  max_retries?: number\n  retry_delay_ms?: number\n  error_status?: number\n  error?: string\n  [key: string]: unknown\n}\n\n/** An `assistant`/`user` message line. `parent_tool_use_id` distinguishes subagent from main-conversation text. */\nexport interface ClaudeMessageLine {\n  type: 'assistant' | 'user'\n  parent_tool_use_id?: string | null\n  message?: {\n    id?: string\n    content?: Array<{ type: string; text?: string; [key: string]: unknown }>\n    [key: string]: unknown\n  }\n  [key: string]: unknown\n}\n\n/** A `stream_event` line — a partial message delta under `--include-partial-messages`. */\nexport interface ClaudeStreamEventLine {\n  type: 'stream_event'\n  event?: {\n    type?: string\n    delta?: { type?: string; text?: string; [key: string]: unknown }\n    [key: string]: unknown\n  }\n  parent_tool_use_id?: string | null\n  [key: string]: unknown\n}\n\n/** The terminal `result` line — always exactly one per turn, success or error. */\nexport interface ClaudeResultLine {\n  type: 'result'\n  subtype?: string\n  is_error?: boolean\n  result?: string\n  session_id?: string\n  total_cost_usd?: number\n  usage?: Record<string, unknown>\n  stop_reason?: string\n  [key: string]: unknown\n}\n\nexport type ClaudeStreamJsonLine =\n  | ClaudeSystemInitLine\n  | ClaudeSystemApiRetryLine\n  | ClaudeMessageLine\n  | ClaudeStreamEventLine\n  | ClaudeResultLine\n\n/**\n * Parse one already-newline-split `claude --output-format stream-json` line. Returns `undefined`\n * for anything that fails to parse as JSON or does not match a recognized `type` — the caller\n * (`wrapper.ts`) treats an `undefined` result as a non-fatal `log` event at `trace`, never throws.\n */\nexport const parseClaudeStreamJsonLine = (raw: string): ClaudeStreamJsonLine | undefined => {\n  const trimmed = raw.trim()\n  if (trimmed.length === 0) return undefined\n  let value: unknown\n  try {\n    value = JSON.parse(trimmed)\n  } catch {\n    return undefined\n  }\n  if (value === null || typeof value !== 'object') return undefined\n  const obj = value as Record<string, unknown>\n  const type = obj.type\n  if (type === 'system' && obj.subtype === 'init') return obj as unknown as ClaudeSystemInitLine\n  if (type === 'system' && obj.subtype === 'api_retry')\n    return obj as unknown as ClaudeSystemApiRetryLine\n  if (type === 'assistant' || type === 'user') return obj as unknown as ClaudeMessageLine\n  if (type === 'stream_event') return obj as unknown as ClaudeStreamEventLine\n  if (type === 'result') return obj as unknown as ClaudeResultLine\n  return undefined\n}\n\n/**\n * Extract the plain-text delta from a `stream_event` line's content-block delta, or `undefined`\n * if this particular stream_event carries no text delta (e.g. a tool-call-argument delta, which\n * this battery does not surface as message text).\n */\nexport const extractStreamEventTextDelta = (line: ClaudeStreamEventLine): string | undefined => {\n  const delta = line.event?.delta\n  if (!delta) return undefined\n  if (delta.type === 'text_delta' && typeof delta.text === 'string') return delta.text\n  return undefined\n}\n\n/** Extract the concatenated plain text from a complete (non-streamed) assistant/user message line. */\nexport const extractMessageText = (line: ClaudeMessageLine): string => {\n  const blocks = line.message?.content\n  if (!Array.isArray(blocks)) return ''\n  return blocks\n    .filter((b) => b.type === 'text' && typeof b.text === 'string')\n    .map((b) => b.text as string)\n    .join('')\n}\n","#!/usr/bin/env node\n/**\n * Standalone Node entry point that owns all Claude-Code-specific complexity: spawning the real\n * `claude` binary, hosting the MCP bridge, and translating its stream-json into the normalized\n * adapter↔wrapper protocol.\n *\n * @remarks\n * Self-contained with respect to `@nhtio/adk/*` — no such imports anywhere in this file or its\n * three siblings (`wire.ts`, `cli_protocol.ts`, `mcp_bridge.ts`). Only `node:*` builtins,\n * `@modelcontextprotocol/sdk`, and those three battery-local modules. Ships as a sibling dist\n * asset (see Decision C in the design notes) — never imported as a library, only ever spawned by\n * file path via `execa(process.execPath, [wrapperPath])` from `adapter.ts`.\n *\n * Carries no `@module` JSDoc tag: it is invisible to the `@module`-tag scraper that builds the\n * public `exports` map, and is added to `vite.config.mts`'s `build.lib.entry` as an explicit extra\n * key instead, following the `mcp/server.ts` precedent for a non-consumer-facing standalone\n * executable.\n */\n\nimport { spawn } from 'node:child_process'\nimport { startMcpBridge } from './mcp_bridge'\nimport { createNdjsonLineReader, encodeWrapperEvent } from './wire'\nimport {\n  parseClaudeStreamJsonLine,\n  extractStreamEventTextDelta,\n  extractMessageText,\n} from './cli_protocol'\nimport type { McpBridge } from './mcp_bridge'\nimport type { ChildProcess } from 'node:child_process'\nimport type { WrapperCommand, WrapperRunCommand, WrapperEvent, ClaudeCodeCliExtraArg } from './wire'\n\n// ─── stdout writer (every emit is an awaited, flush-confirmed write) ───────────\n\nconst writeEvent = (event: WrapperEvent): Promise<void> =>\n  new Promise<void>((resolve, reject) => {\n    process.stdout.write(encodeWrapperEvent(event), (err) => (err ? reject(err) : resolve()))\n  })\n\nconst log = (\n  level: 'trace' | 'debug' | 'info' | 'warn' | 'error',\n  kind: string,\n  message: string,\n  payload?: unknown\n): void => {\n  void writeEvent({ type: 'log', level, kind, message, payload }).catch(() => {})\n}\n\n// ─── stdin command reader ───────────────────────────────────────────────────\n\nlet stdinDataListener: ((chunk: Uint8Array) => void) | undefined\nlet stdinEndListener: (() => void) | undefined\n\n/** Stop the stdin command reader and detach its listeners — called on every exit path. */\nconst stopStdinReader = (): void => {\n  if (stdinDataListener) process.stdin.off('data', stdinDataListener)\n  if (stdinEndListener) process.stdin.off('end', stdinEndListener)\n  stdinDataListener = undefined\n  stdinEndListener = undefined\n  try {\n    process.stdin.pause()\n  } catch {\n    /* stdin may already be gone */\n  }\n}\n\n// ─── argv construction (Decision F0) ───────────────────────────────────────\n\n/** Validate one `extraArgs` entry has already been checked by the adapter; convert it to argv tokens. */\nconst extraArgToArgv = (entry: ClaudeCodeCliExtraArg): string[] => {\n  if (entry.value === undefined) return [entry.flag]\n  if (Array.isArray(entry.value)) return [entry.flag, ...entry.value]\n  return [entry.flag, entry.value]\n}\n\n/** Build the complete, authoritative argv for the `claude` grandchild. */\nconst buildClaudeArgv = (cmd: WrapperRunCommand, bridgeUrl: string): string[] => {\n  const args: string[] = [\n    '--bare',\n    '-p',\n    '--verbose',\n    '--output-format',\n    'stream-json',\n    '--include-partial-messages',\n    '--no-session-persistence',\n    '--tools',\n    '',\n    '--strict-mcp-config',\n    '--mcp-config',\n    JSON.stringify({ mcpServers: { adk_bridge: { type: 'http', url: bridgeUrl } } }),\n    '--dangerously-skip-permissions',\n  ]\n  // --allowedTools: OMITTED ENTIRELY when there are no bridged tools — the flag is variadic, and a\n  // bare `--allowedTools` with nothing after it swallows the very next argv token (confirmed by\n  // direct reproduction against the live CLI during design).\n  if (cmd.allowedTools.length > 0) {\n    args.push(\n      '--allowedTools',\n      cmd.allowedTools.map((name) => `mcp__adk_bridge__${name}`).join(',')\n    )\n  }\n  if (cmd.appendSystemPrompt !== undefined) {\n    args.push('--append-system-prompt', cmd.appendSystemPrompt)\n  }\n  if (cmd.model !== undefined) {\n    args.push('--model', cmd.model)\n  }\n  if (cmd.addDir !== undefined && cmd.addDir.length > 0) {\n    args.push('--add-dir', ...cmd.addDir)\n  }\n  if (cmd.maxBudgetUsd !== undefined) {\n    args.push('--max-budget-usd', String(cmd.maxBudgetUsd))\n  }\n  // Fixed single-turn dispatch contract: the harness owns iteration boundaries.\n  args.push('--max-turns', '1')\n  if (cmd.fallbackModel !== undefined && cmd.fallbackModel.length > 0) {\n    // ONE comma-joined value, never separate argv tokens — confirmed by direct reproduction: the\n    // flag is singular (`--fallback-model <model>`) and documented as accepting \"a comma-separated\n    // list to try each in order.\"\n    args.push('--fallback-model', cmd.fallbackModel.join(','))\n  }\n  if (cmd.forwardSubagentText === true) {\n    args.push('--forward-subagent-text')\n  }\n  for (const entry of cmd.extraArgs ?? []) {\n    args.push(...extraArgToArgv(entry))\n  }\n  args.push('--', cmd.prompt)\n  return args\n}\n\n/** Build the grandchild's env: start from the ambient env, then explicitly delete-then-set every credential/behavior variable this command controls. */\nconst buildClaudeEnv = (cmd: WrapperRunCommand): Record<string, string | undefined> => {\n  const env: Record<string, string | undefined> = { ...process.env }\n  delete env.ANTHROPIC_API_KEY\n  delete env.ANTHROPIC_AUTH_TOKEN\n  delete env.ANTHROPIC_BASE_URL\n  delete env.DISABLE_TELEMETRY\n  delete env.DISABLE_ERROR_REPORTING\n  delete env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC\n  delete env.CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT\n  if (cmd.auth?.apiKey !== undefined) env.ANTHROPIC_API_KEY = cmd.auth.apiKey\n  if (cmd.auth?.authToken !== undefined) env.ANTHROPIC_AUTH_TOKEN = cmd.auth.authToken\n  if (cmd.auth?.baseUrl !== undefined) env.ANTHROPIC_BASE_URL = cmd.auth.baseUrl\n  if (cmd.disableTelemetry === true) env.DISABLE_TELEMETRY = '1'\n  if (cmd.disableErrorReporting === true) env.DISABLE_ERROR_REPORTING = '1'\n  if (cmd.disableNonessentialTraffic === true) env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1'\n  if (cmd.mcpToolIdleTimeoutMs !== undefined) {\n    env.CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT = String(cmd.mcpToolIdleTimeoutMs)\n  }\n  return env\n}\n\n// ─── main ───────────────────────────────────────────────────────────────────\n\nconst main = async (): Promise<void> => {\n  let bridge: McpBridge | undefined\n  let grandchild: ChildProcess | undefined\n  let shuttingDown = false\n  let sawResult = false\n\n  /** Kill the grandchild's entire detached process group. POSIX only (enforced by the adapter's own options validation before this wrapper is ever spawned). */\n  const killGrandchildGroup = (signal: NodeJS.Signals): void => {\n    if (!grandchild || grandchild.pid === undefined || grandchild.exitCode !== null) return\n    try {\n      process.kill(-grandchild.pid, signal)\n    } catch {\n      /* the group may already be gone */\n    }\n  }\n\n  /** Await the grandchild's actual exit for a bounded period; fall through to a process-group kill if it hasn't exited in time. */\n  const waitForGrandchildExit = async (graceMs: number): Promise<void> => {\n    if (!grandchild || grandchild.exitCode !== null || grandchild.signalCode !== null) return\n    const exited = await new Promise<boolean>((resolve) => {\n      const timer = setTimeout(() => resolve(false), graceMs)\n      grandchild?.once('exit', () => {\n        clearTimeout(timer)\n        resolve(true)\n      })\n    })\n    if (!exited) {\n      killGrandchildGroup('SIGTERM')\n    }\n  }\n\n  /**\n   * The corrected shutdown sequence (Decision D step 5), shared by the normal-completion path and\n   * the SIGTERM/SIGINT handler. Order matters: reject pending calls, THEN close the transport\n   * (which tears down any open SSE stream), THEN close the HTTP listener (now genuinely\n   * unblocked), THEN bound-wait/kill the grandchild, THEN flush `shutdown_complete`, THEN stop the\n   * stdin reader.\n   */\n  const runShutdownSequence = async (disposeGraceMs: number): Promise<void> => {\n    bridge?.rejectPending('The Claude Code CLI wrapper is shutting down.')\n    if (bridge) await bridge.closeTransport()\n    if (bridge) await bridge.closeHttpServer()\n    await waitForGrandchildExit(disposeGraceMs)\n    await writeEvent({ type: 'shutdown_complete' }).catch(() => {})\n    stopStdinReader()\n  }\n\n  // A 5-second backstop, entirely separate from the normal-completion path: if the graceful\n  // sequence above hangs, this fires, force-kills the grandchild's process group unconditionally,\n  // and calls process.exit(1) — the ONE and ONLY process.exit() call on the normal-completion path.\n  let backstopTimer: ReturnType<typeof setTimeout> | undefined\n  const armBackstop = (): void => {\n    backstopTimer = setTimeout(() => {\n      killGrandchildGroup('SIGKILL')\n      process.exitCode = 1\n      process.exit(1)\n    }, 5_000)\n  }\n  const disarmBackstop = (): void => {\n    if (backstopTimer) clearTimeout(backstopTimer)\n    backstopTimer = undefined\n  }\n\n  const shutdownNormally = async (disposeGraceMs: number): Promise<void> => {\n    if (shuttingDown) return\n    shuttingDown = true\n    armBackstop()\n    await runShutdownSequence(disposeGraceMs)\n    disarmBackstop()\n    process.exitCode = 0\n    // Natural return — never process.exit() on this path, so a stdout write in flight is never\n    // truncated by an immediate process termination.\n  }\n\n  // Idempotent SIGTERM/SIGINT handling. Registering a handler REPLACES Node's default\n  // terminate-on-signal behavior, so — unlike the normal-completion path — this path explicitly\n  // calls process.exit() itself once the shutdown sequence completes.\n  let handlingSignal = false\n  const onSignal = (): void => {\n    if (handlingSignal) return\n    handlingSignal = true\n    void runShutdownSequence(2_000)\n      .then(() => process.exit(0))\n      .catch(() => process.exit(1))\n  }\n  process.on('SIGTERM', onSignal)\n  process.on('SIGINT', onSignal)\n  // Final, synchronous, best-effort safety net — cannot await anything per Node's own `exit` event\n  // contract, so it is not the primary cleanup mechanism for any path above.\n  process.on('exit', () => {\n    killGrandchildGroup('SIGTERM')\n  })\n\n  let runCommand: WrapperRunCommand | undefined\n\n  const handleCommand = (command: WrapperCommand): void => {\n    if (command.type === 'run') {\n      if (runCommand !== undefined) {\n        log('error', 'duplicate-run-command', 'A run command was already accepted; ignoring.')\n        return\n      }\n      runCommand = command\n      void startTurn(command)\n      return\n    }\n    if (command.type === 'tool_call_response') {\n      bridge?.resolveToolCall(command.requestId, command.results)\n      return\n    }\n    if (command.type === 'shutdown') {\n      void shutdownNormally(runCommand ? 2_000 : 0)\n      return\n    }\n  }\n\n  const commandReader = createNdjsonLineReader<WrapperCommand>((raw) => {\n    let command: WrapperCommand\n    try {\n      command = JSON.parse(raw) as WrapperCommand\n    } catch {\n      log('trace', 'malformed-command', 'Failed to parse inbound command line; skipping.', {\n        linePreview: raw.slice(0, 256),\n      })\n      return undefined\n    }\n    handleCommand(command)\n    return command\n  })\n  stdinDataListener = (chunk) => commandReader.push(chunk)\n  stdinEndListener = () => commandReader.end()\n  process.stdin.on('data', stdinDataListener)\n  process.stdin.on('end', stdinEndListener)\n\n  // The bridge starts and binds its port IMMEDIATELY at wrapper boot, with an empty tool set —\n  // NOT inside `startTurn`. The adapter waits for `ready` before ever sending `run` (which is what\n  // carries the real tool list), so starting the bridge only after `run` arrives would deadlock\n  // both sides: the adapter waiting for `ready`, the wrapper waiting for `run`. `run`'s own\n  // handling (`startTurn`, below) calls `bridge.setBridgedTools(...)` once the real list is known,\n  // before spawning `claude`.\n  try {\n    bridge = await startMcpBridge((requestId, toolName, args) => {\n      void writeEvent({ type: 'tool_call_request', requestId, tool: toolName, args })\n    })\n  } catch (err) {\n    await writeEvent({\n      type: 'error',\n      message: 'Failed to start the MCP bridge.',\n      // eslint-disable-next-line adk/prefer-is-error -- self-contained wrt @nhtio/adk/* (Decision A)\n      detail: err instanceof Error ? err.message : String(err),\n    }).catch(() => {})\n    process.exitCode = 1\n    return\n  }\n\n  await writeEvent({ type: 'ready' })\n\n  const startTurn = async (command: WrapperRunCommand): Promise<void> => {\n    if (!bridge) return\n    bridge.setBridgedTools(command.bridgedTools)\n\n    const bridgeUrl = `http://127.0.0.1:${bridge.port}/`\n    const argv = buildClaudeArgv(command, bridgeUrl)\n    const env = buildClaudeEnv(command)\n\n    grandchild = spawn(command.claudeBin, argv, {\n      cwd: command.cwd,\n      env,\n      detached: true,\n      stdio: ['ignore', 'pipe', 'pipe'],\n    })\n\n    let partialMessageId: string | undefined\n\n    const dispatchReader = createNdjsonLineReader((raw) => {\n      const line = parseClaudeStreamJsonLine(raw)\n      if (line === undefined) {\n        log(\n          'trace',\n          'malformed-stream-json',\n          'Failed to parse Claude stream-json line; skipping.',\n          {\n            linePreview: raw.slice(0, 256),\n          }\n        )\n        return undefined\n      }\n      void handleClaudeLine(line)\n      return line\n    })\n    grandchild.stdout?.on('data', (chunk: Uint8Array) => {\n      dispatchReader.push(chunk)\n    })\n\n    const handleClaudeLine = async (\n      line: ReturnType<typeof parseClaudeStreamJsonLine>\n    ): Promise<void> => {\n      if (line === undefined) return\n      if (line.type === 'system' && line.subtype === 'init') {\n        const mcpServerErrors = Array.isArray(line.mcp_servers)\n          ? line.mcp_servers\n              .filter((s) => s.status === 'failed' && s.name === 'adk_bridge')\n              .map((s) => s.name)\n          : []\n        await writeEvent({\n          type: 'init',\n          model: line.model,\n          tools: line.tools,\n          mcpServerErrors: mcpServerErrors.length > 0 ? mcpServerErrors : undefined,\n          raw: line,\n        })\n        return\n      }\n      if (line.type === 'system' && line.subtype === 'api_retry') {\n        await writeEvent({\n          type: 'retry',\n          attempt: line.attempt ?? 0,\n          maxRetries: line.max_retries,\n          retryDelayMs: line.retry_delay_ms,\n          errorStatus: line.error_status,\n          error: line.error,\n        })\n        return\n      }\n      if (line.type === 'stream_event') {\n        if (line.parent_tool_use_id && command.forwardSubagentText !== true) return\n        const delta = extractStreamEventTextDelta(line)\n        if (delta !== undefined) {\n          const id = partialMessageId ?? 'message'\n          partialMessageId = id\n          await writeEvent({ type: 'message_delta', id, delta })\n        }\n        return\n      }\n      if (line.type === 'assistant' || line.type === 'user') {\n        if (line.parent_tool_use_id && command.forwardSubagentText !== true) return\n        const text = extractMessageText(line)\n        if (text.length > 0) {\n          const id = partialMessageId ?? 'message'\n          // If no prior stream_event deltas arrived for this id, the complete message carries the\n          // ONLY copy of the text — send it as the delta itself, not an empty seal, or the\n          // adapter's per-id accumulator (which treats the first call's deltaText as the full\n          // content) would create an empty message despite real text having arrived.\n          const delta = partialMessageId === undefined ? text : ''\n          await writeEvent({ type: 'message_delta', id, delta, isComplete: true })\n          partialMessageId = id\n        }\n        return\n      }\n      if (line.type === 'result') {\n        sawResult = true\n        await writeEvent({\n          type: 'result',\n          resultText: line.result,\n          sessionId: line.session_id,\n          totalCostUsd: line.total_cost_usd,\n          usage: line.usage,\n          isError: line.is_error === true,\n          subtype: line.subtype,\n          stopReason: line.stop_reason,\n          raw: line,\n        })\n        await shutdownNormally(2_000)\n      }\n    }\n\n    grandchild.on('error', (err) => {\n      void writeEvent({\n        type: 'error',\n        message: 'The claude grandchild process failed to spawn.',\n        detail: err.message,\n      }).catch(() => {})\n    })\n    grandchild.on('exit', (code, signal) => {\n      if (sawResult || shuttingDown) return\n      void writeEvent({\n        type: 'error',\n        message: `claude exited (code=${String(code)}, signal=${String(signal)}) with no terminal result observed.`,\n      }).catch(() => {})\n    })\n  }\n}\n\nmain().catch((error: unknown) => {\n  // eslint-disable-next-line adk/prefer-is-error -- self-contained wrt @nhtio/adk/* (Decision A)\n  const message = error instanceof Error ? error.message : String(error)\n  process.stderr.write(`claude_code_cli wrapper fatal: ${message}\\n`)\n  process.exitCode = 1\n})\n"],"x_google_ignoreList":[0,1,2],"mappings":";;;;;;;;;;;AASA,IAAI,eAAe,cAAc,MAAM;CACrC,YAAY,SAAS,SAAS;EAC5B,MAAM,SAAS,OAAO;EACtB,KAAK,OAAO;CACd;AACF;AACA,IAAI,kBAAkB,MAAM;CAC1B,IAAI,aAAa,cACf,OAAO;CAET,OAAO,IAAI,aAAa,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AACjD;AACA,IAAI,gBAAgB,OAAO;AAC3B,IAAI,UAAU,cAAc,cAAc;CACxC,YAAY,OAAO,SAAS;EAC1B,IAAI,OAAO,UAAU,YAAY,mBAAmB,OAClD,QAAQ,MAAM,iBAAiB;EAEjC,IAAI,OAAO,SAAS,MAAM,cAAc,aAEtC,QAAQ,WAAW;EAErB,MAAM,OAAO,OAAO;CACtB;AACF;AACA,IAAI,0BAA0B,aAAa;CACzC,MAAM,eAAe,CAAC;CACtB,MAAM,aAAa,SAAS;CAC5B,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK,GAAG;EAC7C,MAAM,GAAG,IAAI,MAAM,IAAI,IAAI,UAAU;EACrC,IAAI,IAAI,WAAW,CAAC,MACpB,IACE,aAAa,KAAK,CAAC,KAAK,KAAK,CAAC;CAElC;CACA,OAAO,IAAI,QAAQ,YAAY;AACjC;AACA,IAAI,iBAAiB,OAAO,gBAAgB;AAC5C,IAAI,0BAA0B,QAAQ,KAAK,SAAS,UAAU,oBAAoB;CAChF,MAAM,OAAO;EACX;EACA;EACA,QAAQ,gBAAgB;CAC1B;CACA,IAAI,WAAW,SAAS;EACtB,KAAK,SAAS;EACd,MAAM,MAAM,IAAI,QAAQ,KAAK,IAAI;EACjC,OAAO,eAAe,KAAK,UAAU,EACnC,MAAM;GACJ,OAAO;EACT,EACF,CAAC;EACD,OAAO;CACT;CACA,IAAI,EAAE,WAAW,SAAS,WAAW,SACnC,IAAI,aAAa,YAAY,SAAS,mBAAmB,QACvD,KAAK,OAAO,IAAI,eAAe,EAC7B,MAAM,YAAY;EAChB,WAAW,QAAQ,SAAS,OAAO;EACnC,WAAW,MAAM;CACnB,EACF,CAAC;MACI,IAAI,SAAS,iBAAiB;EACnC,IAAI;EACJ,KAAK,OAAO,IAAI,eAAe,EAC7B,MAAM,KAAK,YAAY;GACrB,IAAI;IACF,WAAW,SAAS,MAAM,QAAQ,EAAE,UAAU;IAC9C,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;IAC1C,IAAI,MACF,WAAW,MAAM;SAEjB,WAAW,QAAQ,KAAK;GAE5B,SAAS,OAAO;IACd,WAAW,MAAM,KAAK;GACxB;EACF,EACF,CAAC;CACH,OACE,KAAK,OAAO,SAAS,MAAM,QAAQ;CAGvC,OAAO,IAAI,QAAQ,KAAK,IAAI;AAC9B;AACA,IAAI,kBAAkB,OAAO,iBAAiB;AAC9C,IAAI,eAAe,OAAO,cAAc;AACxC,IAAI,cAAc,OAAO,aAAa;AACtC,IAAI,SAAS,OAAO,QAAQ;AAC5B,IAAI,aAAa,OAAO,YAAY;AACpC,IAAI,qBAAqB,OAAO,oBAAoB;AAEpD,IAAI,mBAAmB;CACrB,IAAI,SAAS;EACX,OAAO,KAAK,aAAa,UAAU;CACrC;CACA,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CACA,IAAI,UAAU;EACZ,OAAO,KAAK,gBAAgB,uBAAuB,KAAK,YAAY;CACtE;CACA,CAXuB,OAAO,oBAWZ,KAAK;EACrB,KAAK,iBAAiB;EACtB,OAAO,KAAK;CACd;CACA,CAAC,mBAAmB;EAClB,KAAK,wBAAwB,IAAI,gBAAgB;EACjD,OAAO,KAAK,kBAAkB,uBAC5B,KAAK,QACL,KAAK,SACL,KAAK,SACL,KAAK,cACL,KAAK,mBACP;CACF;AACF;AACA;CACE;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,EAAE,SAAS,MAAM;CACf,OAAO,eAAe,kBAAkB,GAAG,EACzC,MAAM;EACJ,OAAO,KAAK,iBAAiB,EAAE;CACjC,EACF,CAAC;AACH,CAAC;AACD;CAAC;CAAe;CAAQ;CAAS;CAAY;CAAQ;AAAM,EAAE,SAAS,MAAM;CAC1E,OAAO,eAAe,kBAAkB,GAAG,EACzC,OAAO,WAAW;EAChB,OAAO,KAAK,iBAAiB,EAAE,GAAG;CACpC,EACF,CAAC;AACH,CAAC;AACD,OAAO,eAAe,kBAAkB,OAAO,IAAI,4BAA4B,GAAG,EAChF,OAAO,SAAS,OAAO,SAAS,WAAW;CAOzC,OAAO,yBAAyB,UAAU;EALxC,QAAQ,KAAK;EACb,KAAK,KAAK;EACV,SAAS,KAAK;EACd,eAAe,KAAK;CAEwB,GAAG;EAAE,GAAG;EAAS,OAAO,SAAS,OAAO,OAAO,QAAQ;CAAE,CAAC;AAC1G,EACF,CAAC;AACD,OAAO,eAAe,kBAAkB,QAAQ,SAAS;AACzD,IAAI,cAAc,UAAU,oBAAoB;CAC9C,MAAM,MAAM,OAAO,OAAO,gBAAgB;CAC1C,IAAI,eAAe;CACnB,MAAM,cAAc,SAAS,OAAO;CACpC,IAAI,YAAY,OAAO,QACtB,YAAY,WAAW,SAAS,KAAK,YAAY,WAAW,UAAU,IAAI;EACzE,IAAI,oBAAoB,oBACtB,MAAM,IAAI,aAAa,iDAAiD;EAE1E,IAAI;GAEF,IAAI,UAAU,IADG,IAAI,WACJ,EAAE;EACrB,SAAS,GAAG;GACV,MAAM,IAAI,aAAa,wBAAwB,EAAE,OAAO,EAAE,CAAC;EAC7D;EACA,OAAO;CACT;CACA,MAAM,QAAQ,oBAAoB,qBAAqB,SAAS,YAAY,SAAS,QAAQ,SAAS;CACtG,IAAI,CAAC,MACH,MAAM,IAAI,aAAa,qBAAqB;CAE9C,IAAI;CACJ,IAAI,oBAAoB,oBAAoB;EAC1C,SAAS,SAAS;EAClB,IAAI,EAAE,WAAW,UAAU,WAAW,UACpC,MAAM,IAAI,aAAa,oBAAoB;CAE/C,OACE,SAAS,SAAS,UAAU,SAAS,OAAO,YAAY,UAAU;CAEpE,MAAM,MAAM,IAAI,IAAI,GAAG,OAAO,KAAK,OAAO,aAAa;CACvD,IAAI,IAAI,SAAS,WAAW,KAAK,UAAU,IAAI,aAAa,KAAK,QAAQ,SAAS,EAAE,GAClF,MAAM,IAAI,aAAa,qBAAqB;CAE9C,IAAI,UAAU,IAAI;CAClB,OAAO;AACT;AAGA,IAAI,gBAAgB,OAAO,eAAe;AAC1C,IAAI,mBAAmB,OAAO,kBAAkB;AAChD,IAAI,WAAW,OAAO,OAAO;AAC7B,IAAI,iBAAiB,OAAO;AAC5B,IAAI,YAAY,MAAM,UAAU;CAC9B;CACA;CACA,CAAC,oBAAoB;EACnB,OAAO,KAAK;EACZ,OAAO,KAAK,mBAAmB,IAAI,eAAe,KAAKA,OAAO,KAAKC,KAAK;CAC1E;CACA,YAAY,MAAM,MAAM;EACtB,IAAI;EACJ,KAAKD,QAAQ;EACb,IAAI,gBAAgB,WAAW;GAC7B,MAAM,uBAAuB,KAAK;GAClC,IAAI,sBAAsB;IACxB,KAAKC,QAAQ;IACb,KAAK,kBAAkB;IACvB;GACF,OAAO;IACL,KAAKA,QAAQ,KAAKA;IAClB,UAAU,IAAI,QAAQ,KAAKA,MAAM,OAAO;GAC1C;EACF,OACE,KAAKA,QAAQ;EAEf,IAAI,OAAO,SAAS,YAAY,OAAO,MAAM,cAAc,eAAe,gBAAgB,QAAQ,gBAAgB,YAEhH,KAAK,YAAY;GAAC,MAAM,UAAU;GAAK;GAAM,WAAW,MAAM;EAAO;CAEzE;CACA,IAAI,UAAU;EACZ,MAAM,QAAQ,KAAK;EACnB,IAAI,OAAO;GACT,IAAI,EAAE,MAAM,cAAc,UACxB,MAAM,KAAK,IAAI,QACb,MAAM,MAAM,EAAE,gBAAgB,4BAA4B,CAC5D;GAEF,OAAO,MAAM;EACf;EACA,OAAO,KAAK,kBAAkB,EAAE;CAClC;CACA,IAAI,SAAS;EACX,OAAO,KAAK,YAAY,MAAM,KAAK,kBAAkB,EAAE;CACzD;CACA,IAAI,KAAK;EACP,MAAM,SAAS,KAAK;EACpB,OAAO,UAAU,OAAO,SAAS;CACnC;AACF;AACA;CAAC;CAAQ;CAAY;CAAc;CAAc;CAAY;CAAQ;AAAK,EAAE,SAAS,MAAM;CACzF,OAAO,eAAe,UAAU,WAAW,GAAG,EAC5C,MAAM;EACJ,OAAO,KAAK,kBAAkB,EAAE;CAClC,EACF,CAAC;AACH,CAAC;AACD;CAAC;CAAe;CAAQ;CAAS;CAAY;CAAQ;AAAM,EAAE,SAAS,MAAM;CAC1E,OAAO,eAAe,UAAU,WAAW,GAAG,EAC5C,OAAO,WAAW;EAChB,OAAO,KAAK,kBAAkB,EAAE,GAAG;CACrC,EACF,CAAC;AACH,CAAC;AACD,OAAO,eAAe,UAAU,WAAW,OAAO,IAAI,4BAA4B,GAAG,EACnF,OAAO,SAAS,OAAO,SAAS,WAAW;CAOzC,OAAO,0BAA0B,UAAU;EALzC,QAAQ,KAAK;EACb,SAAS,KAAK;EACd,IAAI,KAAK;EACT,gBAAgB,KAAK;CAEwB,GAAG;EAAE,GAAG;EAAS,OAAO,SAAS,OAAO,OAAO,QAAQ;CAAE,CAAC;AAC3G,EACF,CAAC;AACD,OAAO,eAAe,WAAW,cAAc;AAC/C,OAAO,eAAe,UAAU,WAAW,eAAe,SAAS;AAGnE,eAAe,oBAAoB,aAAa;CAC9C,OAAO,QAAQ,KAAK,CAAC,aAAa,QAAQ,QAAQ,EAAE,WAAW,QAAQ,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC;AAC1F;AACA,SAAS,qCAAqC,QAAQ,UAAU,oBAAoB;CAClF,MAAM,UAAU,UAAU;EACxB,OAAO,OAAO,KAAK,EAAE,YAAY,CACjC,CAAC;CACH;CACA,SAAS,GAAG,SAAS,MAAM;CAC3B,SAAS,GAAG,SAAS,MAAM;CAC3B,CAAC,sBAAsB,OAAO,KAAK,GAAG,KAAK,MAAM,iBAAiB;CAClE,OAAO,OAAO,OAAO,cAAc;EACjC,SAAS,IAAI,SAAS,MAAM;EAC5B,SAAS,IAAI,SAAS,MAAM;CAC9B,CAAC;CACD,SAAS,kBAAkB,OAAO;EAChC,IAAI,OACF,SAAS,QAAQ,KAAK;CAE1B;CACA,SAAS,UAAU;EACjB,OAAO,KAAK,EAAE,KAAK,MAAM,iBAAiB;CAC5C;CACA,SAAS,KAAK,EAAE,MAAM,SAAS;EAC7B,IAAI;GACF,IAAI,MACF,SAAS,IAAI;QACR,IAAI,CAAC,SAAS,MAAM,KAAK,GAC9B,SAAS,KAAK,SAAS,OAAO;QAE9B,OAAO,OAAO,KAAK,EAAE,KAAK,MAAM,iBAAiB;EAErD,SAAS,GAAG;GACV,kBAAkB,CAAC;EACrB;CACF;AACF;AACA,SAAS,wBAAwB,QAAQ,UAAU;CACjD,IAAI,OAAO,QACT,MAAM,IAAI,UAAU,2BAA2B;MAC1C,IAAI,SAAS,WAClB;CAEF,OAAO,qCAAqC,OAAO,UAAU,GAAG,QAAQ;AAC1E;AACA,IAAI,4BAA4B,YAAY;CAC1C,MAAM,MAAM,CAAC;CACb,IAAI,EAAE,mBAAmB,UACvB,UAAU,IAAI,QAAQ,WAAW,KAAK,CAAC;CAEzC,MAAM,UAAU,CAAC;CACjB,KAAK,MAAM,CAAC,GAAG,MAAM,SACnB,IAAI,MAAM,cACR,QAAQ,KAAK,CAAC;MAEd,IAAI,KAAK;CAGb,IAAI,QAAQ,SAAS,GACnB,IAAI,gBAAgB;CAEtB,IAAI,oBAAoB;CACxB,OAAO;AACT;AAGA,IAAI,iBAAiB;AAIrB,IAAI,OAAO,OAAO,WAAW,aAC3B,OAAO,SAASC;AAIlB,IAAI,gBAAgB,OAAO,eAAe;AAC1C,IAAI,mBAAmB,OAAO,kBAAkB;AAChD,IAAI,mBAAmB;AACvB,IAAI,kBAAkB,KAAK,OAAO;AAClC,IAAI,iBAAiB,aAAa;CAChC,MAAM,yBAAyB;CAC/B,IAAI,SAAS,aAAa,uBAAuB,mBAC/C;CAEF,uBAAuB,oBAAoB;CAC3C,IAAI,oBAAoBC,oBAAqB;EAC3C,IAAI;GAEF,SAAS,QAAQ,QAAQC,UAAY,gBAAgB;EACvD,QAAQ,CACR;EACA;CACF;CACA,IAAI,YAAY;CAChB,MAAM,gBAAgB;EACpB,aAAa,KAAK;EAClB,SAAS,IAAI,QAAQ,MAAM;EAC3B,SAAS,IAAI,OAAO,OAAO;EAC3B,SAAS,IAAI,SAAS,OAAO;CAC/B;CACA,MAAM,mBAAmB;EACvB,QAAQ;EACR,MAAM,SAAS,SAAS;EACxB,IAAI,UAAU,CAAC,OAAO,WACpB,OAAO,YAAY;CAEvB;CACA,MAAM,QAAQ,WAAW,YAAY,gBAAgB;CACrD,MAAM,QAAQ;CACd,MAAM,UAAU,UAAU;EACxB,aAAa,MAAM;EACnB,IAAI,YAAY,iBACd,WAAW;CAEf;CACA,SAAS,GAAG,QAAQ,MAAM;CAC1B,SAAS,GAAG,OAAO,OAAO;CAC1B,SAAS,GAAG,SAAS,OAAO;CAC5B,SAAS,OAAO;AAClB;AACA,IAAI,2BAA2B,IAAI,SAAS,MAAM,EAChD,QAAQ,IACV,CAAC;AACD,IAAI,oBAAoB,MAAM,IAAI,SAAS,MAAM,EAC/C,QAAQ,aAAa,UAAU,EAAE,SAAS,kBAAkB,EAAE,YAAY,SAAS,kBAAkB,MAAM,IAC7G,CAAC;AACD,IAAI,uBAAuB,GAAG,aAAa;CACzC,MAAM,MAAM,aAAa,QAAQ,IAAI,IAAI,MAAM,iBAAiB,EAAE,OAAO,EAAE,CAAC;CAC5E,IAAI,IAAI,SAAS,8BACf,QAAQ,KAAK,6BAA6B;MACrC;EACL,QAAQ,MAAM,CAAC;EACf,IAAI,CAAC,SAAS,aACZ,SAAS,UAAU,KAAK,EAAE,gBAAgB,aAAa,CAAC;EAE1D,SAAS,IAAI,UAAU,IAAI,SAAS;EACpC,SAAS,QAAQ,GAAG;CACtB;AACF;AACA,IAAI,gBAAgB,aAAa;CAC/B,IAAI,kBAAkB,YAAY,SAAS,UACzC,SAAS,aAAa;AAE1B;AACA,IAAI,mBAAmB,OAAO,KAAK,aAAa;CAC9C,IAAI,CAAC,QAAQ,MAAM,UAAU,IAAI;CACjC,IAAI,mBAAmB;CACvB,IAAI,CAAC,QACH,SAAS,EAAE,gBAAgB,4BAA4B;MAClD,IAAI,kBAAkB,SAAS;EACpC,mBAAmB,OAAO,IAAI,gBAAgB;EAC9C,SAAS,yBAAyB,MAAM;CAC1C,OAAO,IAAI,MAAM,QAAQ,MAAM,GAAG;EAChC,MAAM,YAAY,IAAI,QAAQ,MAAM;EACpC,mBAAmB,UAAU,IAAI,gBAAgB;EACjD,SAAS,yBAAyB,SAAS;CAC7C,OACE,KAAK,MAAM,OAAO,QAChB,IAAI,IAAI,WAAW,MAAM,IAAI,YAAY,MAAM,kBAAkB;EAC/D,mBAAmB;EACnB;CACF;CAGJ,IAAI,CAAC;MACC,OAAO,SAAS,UAClB,OAAO,oBAAoB,OAAO,WAAW,IAAI;OAC5C,IAAI,gBAAgB,YACzB,OAAO,oBAAoB,KAAK;OAC3B,IAAI,gBAAgB,MACzB,OAAO,oBAAoB,KAAK;CAAA;CAGpC,SAAS,UAAU,QAAQ,MAAM;CACjC,IAAI,OAAO,SAAS,YAAY,gBAAgB,YAC9C,SAAS,IAAI,IAAI;MACZ,IAAI,gBAAgB,MACzB,SAAS,IAAI,IAAI,WAAW,MAAM,KAAK,YAAY,CAAC,CAAC;MAChD;EACL,aAAa,QAAQ;EACrB,MAAM,wBAAwB,MAAM,QAAQ,GAAG,OAC5C,MAAM,oBAAoB,GAAG,QAAQ,CACxC;CACF;CAEA,SAAS,iBAAiB;AAC5B;AACA,IAAI,aAAa,QAAQ,OAAO,IAAI,SAAS;AAC7C,IAAI,4BAA4B,OAAO,KAAK,UAAU,UAAU,CAAC,MAAM;CACrE,IAAI,UAAU,GAAG,GACf,IAAI,QAAQ,cACV,IAAI;EACF,MAAM,MAAM;CACd,SAAS,KAAK;EACZ,MAAM,SAAS,MAAM,QAAQ,aAAa,GAAG;EAC7C,IAAI,CAAC,QACH;EAEF,MAAM;CACR;MAEA,MAAM,MAAM,IAAI,MAAM,gBAAgB;CAG1C,IAAI,YAAY,KACd,OAAO,iBAAiB,KAAK,QAAQ;CAEvC,MAAM,kBAAkB,yBAAyB,IAAI,OAAO;CAC5D,IAAI,IAAI,MAAM;EACZ,MAAM,SAAS,IAAI,KAAK,UAAU;EAClC,MAAM,SAAS,CAAC;EAChB,IAAI,OAAO;EACX,IAAI,qBAAqB,KAAK;EAC9B,IAAI,gBAAgB,yBAAyB,WAAW;GACtD,IAAI,eAAe;GACnB,KAAK,IAAI,IAAI,GAAG,IAAI,cAAc,KAAK;IACrC,uBAAuB,OAAO,KAAK;IACnC,MAAM,QAAQ,MAAM,oBAAoB,kBAAkB,EAAE,OAAO,MAAM;KACvE,QAAQ,MAAM,CAAC;KACf,OAAO;IACT,CAAC;IACD,IAAI,CAAC,OAAO;KACV,IAAI,MAAM,GAAG;MACX,MAAM,IAAI,SAAS,YAAY,WAAW,OAAO,CAAC;MAClD,eAAe;MACf;KACF;KACA;IACF;IACA,qBAAqB,KAAK;IAC1B,IAAI,MAAM,OACR,OAAO,KAAK,MAAM,KAAK;IAEzB,IAAI,MAAM,MAAM;KACd,OAAO;KACP;IACF;GACF;GACA,IAAI,QAAQ,EAAE,oBAAoB,kBAChC,gBAAgB,oBAAoB,OAAO,QAAQ,KAAK,UAAU,MAAM,MAAM,QAAQ,CAAC;EAE3F;EACA,SAAS,UAAU,IAAI,QAAQ,eAAe;EAC9C,OAAO,SAAS,UAAU;GAExB,SAAS,MAAM,KAAK;EACtB,CAAC;EACD,IAAI,MACF,SAAS,IAAI;OACR;GACL,IAAI,OAAO,WAAW,GACpB,aAAa,QAAQ;GAEvB,MAAM,qCAAqC,QAAQ,UAAU,kBAAkB;EACjF;CACF,OAAO,IAAI,gBAAgB,iBAAiB,CAC5C,OAAO;EACL,SAAS,UAAU,IAAI,QAAQ,eAAe;EAC9C,SAAS,IAAI;CACf;CAEA,SAAS,iBAAiB;AAC5B;AACA,IAAI,sBAAsB,eAAe,UAAU,CAAC,MAAM;CACxD,MAAM,sBAAsB,QAAQ,uBAAuB;CAC3D,IAAI,QAAQ,0BAA0B,SAAS,OAAO,YAAY,SAAS;EACzE,OAAO,eAAe,QAAQ,WAAW,EACvC,OAAO,QACT,CAAC;EACD,OAAO,eAAe,QAAQ,YAAY,EACxC,OAAO,UACT,CAAC;CACH;CACA,OAAO,OAAO,UAAU,aAAa;EACnC,IAAI,KAAK;EACT,IAAI;GACF,MAAM,WAAW,UAAU,QAAQ,QAAQ;GAC3C,IAAI,gBAAgB,CAAC,uBAAuB,SAAS,WAAW,SAAS,SAAS,WAAW;GAC7F,IAAI,CAAC,eAAe;IAElB,SAAS,kBAAkB;IAC3B,SAAS,GAAG,aAAa;KACvB,gBAAgB;IAClB,CAAC;IACD,IAAI,oBAAoBD,oBAEtB,SAAS,uBAAuB;KAC9B,IAAI,CAAC,eACH,iBAAiB;MACf,IAAI,CAAC,eACH,iBAAiB;OACf,cAAc,QAAQ;MACxB,CAAC;KAEL,CAAC;IAEL;IAEF,SAAS,GAAG,gBAAgB;KAC1B,IAAI,CAAC,eACH,cAAc,QAAQ;IAE1B,CAAC;GACH;GACA,SAAS,GAAG,eAAe;IAEzB,IADwB,IAAI;SAEtB,SAAS,SACX,IAAI,oBAAoB,MAAM,SAAS,QAAQ,SAAS,CAAC;UACpD,IAAI,CAAC,SAAS,kBACnB,IAAI,oBAAoB,MAAM,uCAAuC;IAAA;IAGzE,IAAI,CAAC,eACH,iBAAiB;KACf,IAAI,CAAC,eACH,iBAAiB;MACf,cAAc,QAAQ;KACxB,CAAC;IAEL,CAAC;GAEL,CAAC;GACD,MAAM,cAAc,KAAK;IAAE;IAAU;GAAS,CAAC;GAC/C,IAAI,YAAY,KACd,OAAO,iBAAiB,KAAK,QAAQ;EAEzC,SAAS,GAAG;GACV,IAAI,CAAC,KACH,IAAI,QAAQ,cAAc;IACxB,MAAM,MAAM,QAAQ,aAAa,MAAM,IAAI,eAAe,CAAC,CAAC;IAC5D,IAAI,CAAC,KACH;GAEJ,OAAO,IAAI,CAAC,KACV,MAAM,mBAAmB;QAEzB,MAAM,iBAAiB,CAAC;QAG1B,OAAO,oBAAoB,GAAG,QAAQ;EAE1C;EACA,IAAI;GACF,OAAO,MAAM,0BAA0B,KAAK,UAAU,OAAO;EAC/D,SAAS,GAAG;GACV,OAAO,oBAAoB,GAAG,QAAQ;EACxC;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtkBA,IAAa,2CAAb,MAAsD;CAClD,YAAY,UAAU,CAAC,GAAG;EACtB,KAAK,WAAW;EAChB,KAAK,qBAAqB;EAC1B,KAAK,iCAAiB,IAAI,IAAI;EAC9B,KAAK,0CAA0B,IAAI,IAAI;EACvC,KAAK,sCAAsB,IAAI,IAAI;EACnC,KAAK,eAAe;EACpB,KAAK,sBAAsB;EAC3B,KAAK,yBAAyB;EAC9B,KAAK,qBAAqB,QAAQ;EAClC,KAAK,sBAAsB,QAAQ,sBAAsB;EACzD,KAAK,cAAc,QAAQ;EAC3B,KAAK,wBAAwB,QAAQ;EACrC,KAAK,mBAAmB,QAAQ;EAChC,KAAK,gBAAgB,QAAQ;EAC7B,KAAK,kBAAkB,QAAQ;EAC/B,KAAK,gCAAgC,QAAQ,gCAAgC;EAC7E,KAAK,iBAAiB,QAAQ;CAClC;;;;;CAKA,MAAM,QAAQ;EACV,IAAI,KAAK,UACL,MAAM,IAAI,MAAM,2BAA2B;EAE/C,KAAK,WAAW;CACpB;;;;CAIA,wBAAwB,QAAQ,MAAM,SAAS,SAAS;EACpD,MAAM,QAAQ;GAAE;GAAM;EAAQ;EAC9B,IAAI,SAAS,SAAS,KAAA,GAClB,MAAM,OAAO,QAAQ;EAEzB,OAAO,IAAI,SAAS,KAAK,UAAU;GAC/B,SAAS;GACT;GACA,IAAI;EACR,CAAC,GAAG;GACA;GACA,SAAS;IACL,gBAAgB;IAChB,GAAG,SAAS;GAChB;EACJ,CAAC;CACL;;;;;CAKA,uBAAuB,KAAK;EAExB,IAAI,CAAC,KAAK,+BACN;EAGJ,IAAI,KAAK,iBAAiB,KAAK,cAAc,SAAS,GAAG;GACrD,MAAM,aAAa,IAAI,QAAQ,IAAI,MAAM;GACzC,IAAI,CAAC,cAAc,CAAC,KAAK,cAAc,SAAS,UAAU,GAAG;IACzD,MAAM,QAAQ,wBAAwB;IACtC,KAAK,UAAU,IAAI,MAAM,KAAK,CAAC;IAC/B,OAAO,KAAK,wBAAwB,KAAK,OAAQ,KAAK;GAC1D;EACJ;EAEA,IAAI,KAAK,mBAAmB,KAAK,gBAAgB,SAAS,GAAG;GACzD,MAAM,eAAe,IAAI,QAAQ,IAAI,QAAQ;GAC7C,IAAI,gBAAgB,CAAC,KAAK,gBAAgB,SAAS,YAAY,GAAG;IAC9D,MAAM,QAAQ,0BAA0B;IACxC,KAAK,UAAU,IAAI,MAAM,KAAK,CAAC;IAC/B,OAAO,KAAK,wBAAwB,KAAK,OAAQ,KAAK;GAC1D;EACJ;CAEJ;;;;;CAKA,MAAM,cAAc,KAAK,SAAS;EAG9B,IAAI,CAAC,KAAK,sBAAsB,KAAK,oBACjC,MAAM,IAAI,MAAM,2FAA2F;EAE/G,KAAK,qBAAqB;EAE1B,MAAM,kBAAkB,KAAK,uBAAuB,GAAG;EACvD,IAAI,iBACA,OAAO;EAEX,QAAQ,IAAI,QAAZ;GACI,KAAK,QACD,OAAO,KAAK,kBAAkB,KAAK,OAAO;GAC9C,KAAK,OACD,OAAO,KAAK,iBAAiB,GAAG;GACpC,KAAK,UACD,OAAO,KAAK,oBAAoB,GAAG;GACvC,SACI,OAAO,KAAK,yBAAyB;EAC7C;CACJ;;;;;;CAMA,MAAM,kBAAkB,YAAY,SAAS,UAAU,iBAAiB;EACpE,IAAI,CAAC,KAAK,aACN;EAKJ,IAAI,kBAAkB,cAClB;EAEJ,MAAM,iBAAiB,MAAM,KAAK,YAAY,WAAW,UAAU,CAAC,CAAC;EACrE,IAAI,eAAe,OAAO,eAAe;EACzC,IAAI,KAAK,mBAAmB,KAAA,GACxB,eAAe,OAAO,eAAe,WAAW,KAAK,eAAe;EAExE,WAAW,QAAQ,QAAQ,OAAO,YAAY,CAAC;CACnD;;;;CAIA,MAAM,iBAAiB,KAAK;EAGxB,IAAI,CADiB,IAAI,QAAQ,IAAI,QACrB,GAAG,SAAS,mBAAmB,GAAG;GAC9C,KAAK,0BAAU,IAAI,MAAM,sDAAsD,CAAC;GAChF,OAAO,KAAK,wBAAwB,KAAK,OAAQ,sDAAsD;EAC3G;EAIA,MAAM,eAAe,KAAK,gBAAgB,GAAG;EAC7C,IAAI,cACA,OAAO;EAEX,MAAM,gBAAgB,KAAK,wBAAwB,GAAG;EACtD,IAAI,eACA,OAAO;EAGX,IAAI,KAAK,aAAa;GAClB,MAAM,cAAc,IAAI,QAAQ,IAAI,eAAe;GACnD,IAAI,aACA,OAAO,KAAK,aAAa,WAAW;EAE5C;EAEA,IAAI,KAAK,eAAe,IAAI,KAAK,sBAAsB,MAAM,KAAA,GAAW;GAEpE,KAAK,0BAAU,IAAI,MAAM,sDAAsD,CAAC;GAChF,OAAO,KAAK,wBAAwB,KAAK,OAAQ,sDAAsD;EAC3G;EACA,MAAM,UAAU,IAAI,YAAY;EAChC,IAAI;EAEJ,MAAM,WAAW,IAAI,eAAe;GAChC,QAAO,eAAc;IACjB,mBAAmB;GACvB;GACA,cAAc;IAEV,KAAK,eAAe,OAAO,KAAK,sBAAsB;GAC1D;EACJ,CAAC;EACD,MAAM,UAAU;GACZ,gBAAgB;GAChB,iBAAiB;GACjB,YAAY;EAChB;EAEA,IAAI,KAAK,cAAc,KAAA,GACnB,QAAQ,oBAAoB,KAAK;EAGrC,KAAK,eAAe,IAAI,KAAK,wBAAwB;GACjD,YAAY;GACZ;GACA,eAAe;IACX,KAAK,eAAe,OAAO,KAAK,sBAAsB;IACtD,IAAI;KACA,iBAAiB,MAAM;IAC3B,QACM,CAEN;GACJ;EACJ,CAAC;EACD,OAAO,IAAI,SAAS,UAAU,EAAE,QAAQ,CAAC;CAC7C;;;;;CAKA,MAAM,aAAa,aAAa;EAC5B,IAAI,CAAC,KAAK,aAAa;GACnB,KAAK,0BAAU,IAAI,MAAM,4BAA4B,CAAC;GACtD,OAAO,KAAK,wBAAwB,KAAK,OAAQ,4BAA4B;EACjF;EACA,IAAI;GAEA,IAAI;GACJ,IAAI,KAAK,YAAY,uBAAuB;IACxC,WAAW,MAAM,KAAK,YAAY,sBAAsB,WAAW;IACnE,IAAI,CAAC,UAAU;KACX,KAAK,0BAAU,IAAI,MAAM,yBAAyB,CAAC;KACnD,OAAO,KAAK,wBAAwB,KAAK,OAAQ,yBAAyB;IAC9E;IAEA,IAAI,KAAK,eAAe,IAAI,QAAQ,MAAM,KAAA,GAAW;KACjD,KAAK,0BAAU,IAAI,MAAM,mDAAmD,CAAC;KAC7E,OAAO,KAAK,wBAAwB,KAAK,OAAQ,mDAAmD;IACxG;GACJ;GACA,MAAM,UAAU;IACZ,gBAAgB;IAChB,iBAAiB;IACjB,YAAY;GAChB;GACA,IAAI,KAAK,cAAc,KAAA,GACnB,QAAQ,oBAAoB,KAAK;GAGrC,MAAM,UAAU,IAAI,YAAY;GAChC,IAAI;GACJ,MAAM,WAAW,IAAI,eAAe;IAChC,QAAO,eAAc;KACjB,mBAAmB;IACvB;IACA,cAAc,CAGd;GACJ,CAAC;GAED,MAAM,mBAAmB,MAAM,KAAK,YAAY,kBAAkB,aAAa,EAC3E,MAAM,OAAO,SAAS,YAAY;IAE9B,IAAI,CADY,KAAK,cAAc,kBAAkB,SAAS,SAAS,OAC5D,GAAG;KACV,KAAK,0BAAU,IAAI,MAAM,sBAAsB,CAAC;KAChD,IAAI;MACA,iBAAiB,MAAM;KAC3B,QACM,CAEN;IACJ;GACJ,EACJ,CAAC;GACD,KAAK,eAAe,IAAI,kBAAkB;IACtC,YAAY;IACZ;IACA,eAAe;KACX,KAAK,eAAe,OAAO,gBAAgB;KAC3C,IAAI;MACA,iBAAiB,MAAM;KAC3B,QACM,CAEN;IACJ;GACJ,CAAC;GACD,OAAO,IAAI,SAAS,UAAU,EAAE,QAAQ,CAAC;EAC7C,SACO,OAAO;GACV,KAAK,UAAU,KAAK;GACpB,OAAO,KAAK,wBAAwB,KAAK,OAAQ,wBAAwB;EAC7E;CACJ;;;;CAIA,cAAc,YAAY,SAAS,SAAS,SAAS;EACjD,IAAI;GACA,IAAI,YAAY;GAEhB,IAAI,SACA,aAAa,OAAO,QAAQ;GAEhC,aAAa,SAAS,KAAK,UAAU,OAAO,EAAE;GAC9C,WAAW,QAAQ,QAAQ,OAAO,SAAS,CAAC;GAC5C,OAAO;EACX,SACO,OAAO;GACV,KAAK,UAAU,KAAK;GACpB,OAAO;EACX;CACJ;;;;CAIA,2BAA2B;EACvB,KAAK,0BAAU,IAAI,MAAM,qBAAqB,CAAC;EAC/C,OAAO,IAAI,SAAS,KAAK,UAAU;GAC/B,SAAS;GACT,OAAO;IACH,MAAM;IACN,SAAS;GACb;GACA,IAAI;EACR,CAAC,GAAG;GACA,QAAQ;GACR,SAAS;IACL,OAAO;IACP,gBAAgB;GACpB;EACJ,CAAC;CACL;;;;CAIA,MAAM,kBAAkB,KAAK,SAAS;EAClC,IAAI;GAEA,MAAM,eAAe,IAAI,QAAQ,IAAI,QAAQ;GAE7C,IAAI,CAAC,cAAc,SAAS,kBAAkB,KAAK,CAAC,aAAa,SAAS,mBAAmB,GAAG;IAC5F,KAAK,0BAAU,IAAI,MAAM,gFAAgF,CAAC;IAC1G,OAAO,KAAK,wBAAwB,KAAK,OAAQ,gFAAgF;GACrI;GACA,MAAM,KAAK,IAAI,QAAQ,IAAI,cAAc;GACzC,IAAI,CAAC,MAAM,CAAC,GAAG,SAAS,kBAAkB,GAAG;IACzC,KAAK,0BAAU,IAAI,MAAM,+DAA+D,CAAC;IACzF,OAAO,KAAK,wBAAwB,KAAK,OAAQ,+DAA+D;GACpH;GAEA,MAAM,cAAc;IAChB,SAAS,OAAO,YAAY,IAAI,QAAQ,QAAQ,CAAC;IACjD,KAAK,IAAI,IAAI,IAAI,GAAG;GACxB;GACA,IAAI;GACJ,IAAI,SAAS,eAAe,KAAA,GACxB,aAAa,QAAQ;QAGrB,IAAI;IACA,aAAa,MAAM,IAAI,KAAK;GAChC,QACM;IACF,KAAK,0BAAU,IAAI,MAAM,2BAA2B,CAAC;IACrD,OAAO,KAAK,wBAAwB,KAAK,QAAQ,2BAA2B;GAChF;GAEJ,IAAI;GAEJ,IAAI;IACA,IAAI,MAAM,QAAQ,UAAU,GACxB,WAAW,WAAW,KAAI,QAAO,qBAAqB,MAAM,GAAG,CAAC;SAGhE,WAAW,CAAC,qBAAqB,MAAM,UAAU,CAAC;GAE1D,QACM;IACF,KAAK,0BAAU,IAAI,MAAM,uCAAuC,CAAC;IACjE,OAAO,KAAK,wBAAwB,KAAK,QAAQ,uCAAuC;GAC5F;GAGA,MAAM,0BAA0B,SAAS,KAAK,mBAAmB;GACjE,IAAI,yBAAyB;IAGzB,IAAI,KAAK,gBAAgB,KAAK,cAAc,KAAA,GAAW;KACnD,KAAK,0BAAU,IAAI,MAAM,6CAA6C,CAAC;KACvE,OAAO,KAAK,wBAAwB,KAAK,QAAQ,6CAA6C;IAClG;IACA,IAAI,SAAS,SAAS,GAAG;KACrB,KAAK,0BAAU,IAAI,MAAM,6DAA6D,CAAC;KACvF,OAAO,KAAK,wBAAwB,KAAK,QAAQ,6DAA6D;IAClH;IACA,KAAK,YAAY,KAAK,qBAAqB;IAC3C,KAAK,eAAe;IAGpB,IAAI,KAAK,aAAa,KAAK,uBACvB,MAAM,QAAQ,QAAQ,KAAK,sBAAsB,KAAK,SAAS,CAAC;GAExE;GACA,IAAI,CAAC,yBAAyB;IAI1B,MAAM,eAAe,KAAK,gBAAgB,GAAG;IAC7C,IAAI,cACA,OAAO;IAGX,MAAM,gBAAgB,KAAK,wBAAwB,GAAG;IACtD,IAAI,eACA,OAAO;GAEf;GAGA,IAAI,CADgB,SAAS,KAAK,gBACnB,GAAG;IAEd,KAAK,MAAM,WAAW,UAClB,KAAK,YAAY,SAAS;KAAE,UAAU,SAAS;KAAU;IAAY,CAAC;IAE1E,OAAO,IAAI,SAAS,MAAM,EAAE,QAAQ,IAAI,CAAC;GAC7C;GAGA,MAAM,WAAW,OAAO,WAAW;GAInC,MAAM,cAAc,SAAS,MAAK,MAAK,oBAAoB,CAAC,CAAC;GAC7D,MAAM,wBAAwB,cACxB,YAAY,OAAO,kBAClB,IAAI,QAAQ,IAAI,sBAAsB,KAAA;GAC7C,IAAI,KAAK,qBAEL,OAAO,IAAI,SAAQ,YAAW;IAC1B,KAAK,eAAe,IAAI,UAAU;KAC9B,aAAa;KACb,eAAe;MACX,KAAK,eAAe,OAAO,QAAQ;KACvC;IACJ,CAAC;IACD,KAAK,MAAM,WAAW,UAClB,IAAI,iBAAiB,OAAO,GACxB,KAAK,wBAAwB,IAAI,QAAQ,IAAI,QAAQ;IAG7D,KAAK,MAAM,WAAW,UAClB,KAAK,YAAY,SAAS;KAAE,UAAU,SAAS;KAAU;IAAY,CAAC;GAE9E,CAAC;GAGL,MAAM,UAAU,IAAI,YAAY;GAChC,IAAI;GACJ,MAAM,WAAW,IAAI,eAAe;IAChC,QAAO,eAAc;KACjB,mBAAmB;IACvB;IACA,cAAc;KAEV,KAAK,eAAe,OAAO,QAAQ;IACvC;GACJ,CAAC;GACD,MAAM,UAAU;IACZ,gBAAgB;IAChB,iBAAiB;IACjB,YAAY;GAChB;GAEA,IAAI,KAAK,cAAc,KAAA,GACnB,QAAQ,oBAAoB,KAAK;GAIrC,KAAK,MAAM,WAAW,UAClB,IAAI,iBAAiB,OAAO,GAAG;IAC3B,KAAK,eAAe,IAAI,UAAU;KAC9B,YAAY;KACZ;KACA,eAAe;MACX,KAAK,eAAe,OAAO,QAAQ;MACnC,IAAI;OACA,iBAAiB,MAAM;MAC3B,QACM,CAEN;KACJ;IACJ,CAAC;IACD,KAAK,wBAAwB,IAAI,QAAQ,IAAI,QAAQ;GACzD;GAGJ,MAAM,KAAK,kBAAkB,kBAAkB,SAAS,UAAU,qBAAqB;GAEvF,KAAK,MAAM,WAAW,UAAU;IAK5B,IAAI;IACJ,IAAI;IACJ,IAAI,iBAAiB,OAAO,KAAK,KAAK,eAAe,yBAAyB,cAAc;KACxF,uBAAuB;MACnB,KAAK,eAAe,QAAQ,EAAE;KAClC;KACA,iCAAiC;MAC7B,KAAK,yBAAyB;KAClC;IACJ;IACA,KAAK,YAAY,SAAS;KAAE,UAAU,SAAS;KAAU;KAAa;KAAgB;IAAyB,CAAC;GACpH;GAGA,OAAO,IAAI,SAAS,UAAU;IAAE,QAAQ;IAAK;GAAQ,CAAC;EAC1D,SACO,OAAO;GAEV,KAAK,UAAU,KAAK;GACpB,OAAO,KAAK,wBAAwB,KAAK,QAAQ,eAAe,EAAE,MAAM,OAAO,KAAK,EAAE,CAAC;EAC3F;CACJ;;;;CAIA,MAAM,oBAAoB,KAAK;EAC3B,MAAM,eAAe,KAAK,gBAAgB,GAAG;EAC7C,IAAI,cACA,OAAO;EAEX,MAAM,gBAAgB,KAAK,wBAAwB,GAAG;EACtD,IAAI,eACA,OAAO;EAEX,MAAM,QAAQ,QAAQ,KAAK,mBAAmB,KAAK,SAAS,CAAC;EAC7D,MAAM,KAAK,MAAM;EACjB,OAAO,IAAI,SAAS,MAAM,EAAE,QAAQ,IAAI,CAAC;CAC7C;;;;;CAKA,gBAAgB,KAAK;EACjB,IAAI,KAAK,uBAAuB,KAAA,GAG5B;EAEJ,IAAI,CAAC,KAAK,cAAc;GAEpB,KAAK,0BAAU,IAAI,MAAM,qCAAqC,CAAC;GAC/D,OAAO,KAAK,wBAAwB,KAAK,OAAQ,qCAAqC;EAC1F;EACA,MAAM,YAAY,IAAI,QAAQ,IAAI,gBAAgB;EAClD,IAAI,CAAC,WAAW;GAEZ,KAAK,0BAAU,IAAI,MAAM,gDAAgD,CAAC;GAC1E,OAAO,KAAK,wBAAwB,KAAK,OAAQ,gDAAgD;EACrG;EACA,IAAI,cAAc,KAAK,WAAW;GAE9B,KAAK,0BAAU,IAAI,MAAM,mBAAmB,CAAC;GAC7C,OAAO,KAAK,wBAAwB,KAAK,QAAQ,mBAAmB;EACxE;CAEJ;;;;;;;;;;;;;;CAcA,wBAAwB,KAAK;EACzB,MAAM,kBAAkB,IAAI,QAAQ,IAAI,sBAAsB;EAC9D,IAAI,oBAAoB,QAAQ,CAAC,4BAA4B,SAAS,eAAe,GAAG;GACpF,KAAK,0BAAU,IAAI,MAAM,8CAA8C,gBAAA,wBAC1C,4BAA4B,KAAK,IAAI,EAAE,EAAE,CAAC;GACvE,OAAO,KAAK,wBAAwB,KAAK,OAAQ,8CAA8C,gBAAgB,wBAAwB,4BAA4B,KAAK,IAAI,EAAE,EAAE;EACpL;CAEJ;CACA,MAAM,QAAQ;EAEV,KAAK,eAAe,SAAS,EAAE,cAAc;GACzC,QAAQ;EACZ,CAAC;EACD,KAAK,eAAe,MAAM;EAE1B,KAAK,oBAAoB,MAAM;EAC/B,KAAK,UAAU;CACnB;;;;;;CAMA,eAAe,WAAW;EACtB,MAAM,WAAW,KAAK,wBAAwB,IAAI,SAAS;EAC3D,IAAI,CAAC,UACD;EACJ,MAAM,SAAS,KAAK,eAAe,IAAI,QAAQ;EAC/C,IAAI,QACA,OAAO,QAAQ;CAEvB;;;;;CAKA,2BAA2B;EACvB,MAAM,SAAS,KAAK,eAAe,IAAI,KAAK,sBAAsB;EAClE,IAAI,QACA,OAAO,QAAQ;CAEvB;CACA,MAAM,KAAK,SAAS,SAAS;EACzB,IAAI,YAAY,SAAS;EACzB,IAAI,wBAAwB,OAAO,KAAK,uBAAuB,OAAO,GAElE,YAAY,QAAQ;EAKxB,IAAI,cAAc,KAAA,GAAW;GAEzB,IAAI,wBAAwB,OAAO,KAAK,uBAAuB,OAAO,GAClE,MAAM,IAAI,MAAM,6FAA6F;GAIjH,IAAI;GACJ,IAAI,KAAK,aAEL,UAAU,MAAM,KAAK,YAAY,WAAW,KAAK,wBAAwB,OAAO;GAEpF,MAAM,gBAAgB,KAAK,eAAe,IAAI,KAAK,sBAAsB;GACzE,IAAI,kBAAkB,KAAA,GAElB;GAGJ,IAAI,cAAc,cAAc,cAAc,SAC1C,KAAK,cAAc,cAAc,YAAY,cAAc,SAAS,SAAS,OAAO;GAExF;EACJ;EAEA,MAAM,WAAW,KAAK,wBAAwB,IAAI,SAAS;EAC3D,IAAI,CAAC,UACD,MAAM,IAAI,MAAM,6CAA6C,OAAO,SAAS,GAAG;EAEpF,MAAM,SAAS,KAAK,eAAe,IAAI,QAAQ;EAC/C,IAAI,CAAC,KAAK,uBAAuB,QAAQ,cAAc,QAAQ,SAAS;GAEpE,IAAI;GACJ,IAAI,KAAK,aACL,UAAU,MAAM,KAAK,YAAY,WAAW,UAAU,OAAO;GAGjE,KAAK,cAAc,OAAO,YAAY,OAAO,SAAS,SAAS,OAAO;EAC1E;EACA,IAAI,wBAAwB,OAAO,KAAK,uBAAuB,OAAO,GAAG;GACrE,KAAK,oBAAoB,IAAI,WAAW,OAAO;GAC/C,MAAM,aAAa,MAAM,KAAK,KAAK,wBAAwB,QAAQ,CAAC,EAC/D,QAAQ,CAAC,GAAG,SAAS,QAAQ,QAAQ,EACrC,KAAK,CAAC,QAAQ,EAAE;GAGrB,IAD0B,WAAW,OAAM,OAAM,KAAK,oBAAoB,IAAI,EAAE,CAC5D,GAAG;IACnB,IAAI,CAAC,QACD,MAAM,IAAI,MAAM,6CAA6C,OAAO,SAAS,GAAG;IAEpF,IAAI,KAAK,uBAAuB,OAAO,aAAa;KAEhD,MAAM,UAAU,EACZ,gBAAgB,mBACpB;KACA,IAAI,KAAK,cAAc,KAAA,GACnB,QAAQ,oBAAoB,KAAK;KAErC,MAAM,YAAY,WAAW,KAAI,OAAM,KAAK,oBAAoB,IAAI,EAAE,CAAC;KACvE,IAAI,UAAU,WAAW,GACrB,OAAO,YAAY,IAAI,SAAS,KAAK,UAAU,UAAU,EAAE,GAAG;MAAE,QAAQ;MAAK;KAAQ,CAAC,CAAC;UAGvF,OAAO,YAAY,IAAI,SAAS,KAAK,UAAU,SAAS,GAAG;MAAE,QAAQ;MAAK;KAAQ,CAAC,CAAC;IAE5F,OAGI,OAAO,QAAQ;IAGnB,KAAK,MAAM,MAAM,YAAY;KACzB,KAAK,oBAAoB,OAAO,EAAE;KAClC,KAAK,wBAAwB,OAAO,EAAE;IAC1C;GACJ;EACJ;CACJ;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9rBA,IAAa,gCAAb,MAA2C;CACvC,YAAY,UAAU,CAAC,GAAG;EAEtB,KAAK,kCAAkB,IAAI,QAAQ;EACnC,KAAK,wBAAwB,IAAI,yCAAyC,OAAO;EAKjF,KAAK,mBAAmB,mBAAmB,OAAO,eAAe;GAE7D,MAAM,UAAU,KAAK,gBAAgB,IAAI,UAAU;GACnD,OAAO,KAAK,sBAAsB,cAAc,YAAY;IACxD,UAAU,SAAS;IACnB,YAAY,SAAS;GACzB,CAAC;EACL,GAAG,EAAE,uBAAuB,MAAM,CAAC;CACvC;;;;CAIA,IAAI,YAAY;EACZ,OAAO,KAAK,sBAAsB;CACtC;;;;CAIA,IAAI,QAAQ,SAAS;EACjB,KAAK,sBAAsB,UAAU;CACzC;CACA,IAAI,UAAU;EACV,OAAO,KAAK,sBAAsB;CACtC;;;;CAIA,IAAI,QAAQ,SAAS;EACjB,KAAK,sBAAsB,UAAU;CACzC;CACA,IAAI,UAAU;EACV,OAAO,KAAK,sBAAsB;CACtC;;;;CAIA,IAAI,UAAU,SAAS;EACnB,KAAK,sBAAsB,YAAY;CAC3C;CACA,IAAI,YAAY;EACZ,OAAO,KAAK,sBAAsB;CACtC;;;;;CAKA,MAAM,QAAQ;EACV,OAAO,KAAK,sBAAsB,MAAM;CAC5C;;;;CAIA,MAAM,QAAQ;EACV,OAAO,KAAK,sBAAsB,MAAM;CAC5C;;;;CAIA,MAAM,KAAK,SAAS,SAAS;EACzB,OAAO,KAAK,sBAAsB,KAAK,SAAS,OAAO;CAC3D;;;;;;;;;;;CAWA,MAAM,cAAc,KAAK,KAAK,YAAY;EAGtC,MAAM,WAAW,IAAI;EAYrB,MARgB,mBAAmB,OAAO,eAAe;GACrD,OAAO,KAAK,sBAAsB,cAAc,YAAY;IACxD;IACA;GACJ,CAAC;EACL,GAAG,EAAE,uBAAuB,MAAM,CAGtB,EAAE,KAAK,GAAG;CAC1B;;;;;;CAMA,eAAe,WAAW;EACtB,KAAK,sBAAsB,eAAe,SAAS;CACvD;;;;;CAKA,2BAA2B;EACvB,KAAK,sBAAsB,yBAAyB;CACxD;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3EA,IAAa,iBAAiB,OAC5B,sBACuB;CACvB,MAAM,0BAAU,IAAI,IAAyB;CAC7C,IAAI,gBAAgB;CACpB,IAAI,eAAqC,CAAC;CAE1C,MAAM,SAAS,IAAI,OAAO;EAAE,MAAM;EAAc,SAAS;CAAI,GAAG,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC;CAE/F,OAAO,kBAAkB,+BAA+B,EACtD,OAAO,aAAa,KAAK,OAAO;EAC9B,MAAM,EAAE;EACR,aAAa,EAAE;EACf,aAAa,EAAE;CACjB,EAAE,EACJ,EAAE;CAEF,OAAO,kBAAkB,uBAAuB,OAAO,YAAY;EACjE,MAAM,OAAO,QAAQ,OAAO;EAC5B,IAAI,CAAC,aAAa,MAAM,MAAM,EAAE,SAAS,IAAI,GAI3C,OAAO;GACL,SAAS,CAAC;IAAE,MAAM;IAAQ,MAAM,SAAS,KAAK;GAAqC,CAAC;GACpF,SAAS;EACX;EAEF,MAAM,YAAY,OAAO,eAAe;EAQxC,OAAO,MAPc,IAAI,SAGrB,YAAY;GACd,QAAQ,IAAI,WAAW,EAAE,QAAQ,CAAC;GAClC,kBAAkB,WAAW,MAAM,QAAQ,OAAO,SAAS;EAC7D,CAAC;CAEH,CAAC;CAWD,MAAM,YAAY,IAAI,8BAA8B,EAAE,0BAA0B,WAAW,EAAE,CAAC;CAU9F,MAAM,gCAAgB,IAAI,IAAsB;CAChD,MAAM,eAAe,UAAU,KAAK,KAAK,SAAS;CAClD,UAAU,SAAS,GAAG,SAA0C;EAC9D,MAAM,OAAO,aAAa,GAAG,IAAI;EACjC,cAAc,IAAI,IAAI;EACtB,KAAU,cAAc,cAAc,OAAO,IAAI,CAAC;EAClD,OAAO;CACT;CAEA,MAAM,OAAO,QAAQ,SAAS;CAE9B,MAAM,aAAyB,cAAkB,KAAK,QAAQ;EAC5D,UAAe,cAAc,KAAK,GAAG;CACvC,CAAC;CAcD,OAAO;EACL,MAAA,MAbiB,IAAI,SAAiB,SAAS,WAAW;GAC1D,WAAW,KAAK,SAAS,MAAM;GAC/B,WAAW,OAAO,GAAG,mBAAmB;IACtC,MAAM,UAAU,WAAW,QAAQ;IACnC,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;KACnD,uBAAO,IAAI,MAAM,iDAAiD,CAAC;KACnE;IACF;IACA,QAAQ,QAAQ,IAAI;GACtB,CAAC;EACH,CAAC;EAIC,gBAAgB,OAAO;GACrB,eAAe;EACjB;EACA,gBAAgB,WAAW,QAAQ;GACjC,MAAM,QAAQ,QAAQ,IAAI,SAAS;GACnC,IAAI,CAAC,OAAO;GACZ,QAAQ,OAAO,SAAS;GACxB,MAAM,QAAQ,MAAM;EACtB;EACA,cAAc,QAAQ;GACpB,KAAK,MAAM,CAAC,WAAW,UAAU,SAAS;IACxC,QAAQ,OAAO,SAAS;IACxB,MAAM,QAAQ;KAAE,SAAS,CAAC;MAAE,MAAM;MAAQ,MAAM;KAAO,CAAC;KAAG,SAAS;IAAK,CAAC;GAC5E;EACF;EACA,MAAM,iBAAiB;GAQrB,MAAM,IAAI,SAAe,YAAY,aAAa,OAAO,CAAC;GAC1D,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;IAC1B,MAAM,WAAW,MAAM,KAAK,aAAa;IACzC,IAAI,SAAS,WAAW,GAAG;IAC3B,MAAM,QAAQ,WAAW,QAAQ;GACnC;GACA,MAAM,UAAU,MAAM;EACxB;EACA,MAAM,kBAAkB;GACtB,MAAM,IAAI,SAAe,SAAS,WAAW;IAC3C,WAAW,OAAO,QAAS,MAAM,OAAO,GAAG,IAAI,QAAQ,CAAE;GAC3D,CAAC;EACH;CACF;AACF;;;;;;;;ACzHA,IAAa,6BAA6B,QAAkD;CAC1F,MAAM,UAAU,IAAI,KAAK;CACzB,IAAI,QAAQ,WAAW,GAAG,OAAO,KAAA;CACjC,IAAI;CACJ,IAAI;EACF,QAAQ,KAAK,MAAM,OAAO;CAC5B,QAAQ;EACN;CACF;CACA,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO,KAAA;CACxD,MAAM,MAAM;CACZ,MAAM,OAAO,IAAI;CACjB,IAAI,SAAS,YAAY,IAAI,YAAY,QAAQ,OAAO;CACxD,IAAI,SAAS,YAAY,IAAI,YAAY,aACvC,OAAO;CACT,IAAI,SAAS,eAAe,SAAS,QAAQ,OAAO;CACpD,IAAI,SAAS,gBAAgB,OAAO;CACpC,IAAI,SAAS,UAAU,OAAO;AAEhC;;;;;;AAOA,IAAa,+BAA+B,SAAoD;CAC9F,MAAM,QAAQ,KAAK,OAAO;CAC1B,IAAI,CAAC,OAAO,OAAO,KAAA;CACnB,IAAI,MAAM,SAAS,gBAAgB,OAAO,MAAM,SAAS,UAAU,OAAO,MAAM;AAElF;;AAGA,IAAa,sBAAsB,SAAoC;CACrE,MAAM,SAAS,KAAK,SAAS;CAC7B,IAAI,CAAC,MAAM,QAAQ,MAAM,GAAG,OAAO;CACnC,OAAO,OACJ,QAAQ,MAAM,EAAE,SAAS,UAAU,OAAO,EAAE,SAAS,QAAQ,EAC7D,KAAK,MAAM,EAAE,IAAc,EAC3B,KAAK,EAAE;AACZ;;;;;;;;;;;;;;;;;;;;AC/FA,IAAM,cAAc,UAClB,IAAI,SAAe,SAAS,WAAW;CACrC,QAAQ,OAAO,MAAM,mBAAmB,KAAK,IAAI,QAAS,MAAM,OAAO,GAAG,IAAI,QAAQ,CAAE;AAC1F,CAAC;AAEH,IAAM,OACJ,OACA,MACA,SACA,YACS;CACT,WAAgB;EAAE,MAAM;EAAO;EAAO;EAAM;EAAS;CAAQ,CAAC,EAAE,YAAY,CAAC,CAAC;AAChF;AAIA,IAAI;AACJ,IAAI;;AAGJ,IAAM,wBAA8B;CAClC,IAAI,mBAAmB,QAAQ,MAAM,IAAI,QAAQ,iBAAiB;CAClE,IAAI,kBAAkB,QAAQ,MAAM,IAAI,OAAO,gBAAgB;CAC/D,oBAAoB,KAAA;CACpB,mBAAmB,KAAA;CACnB,IAAI;EACF,QAAQ,MAAM,MAAM;CACtB,QAAQ,CAER;AACF;;AAKA,IAAM,kBAAkB,UAA2C;CACjE,IAAI,MAAM,UAAU,KAAA,GAAW,OAAO,CAAC,MAAM,IAAI;CACjD,IAAI,MAAM,QAAQ,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,MAAM,GAAG,MAAM,KAAK;CAClE,OAAO,CAAC,MAAM,MAAM,MAAM,KAAK;AACjC;;AAGA,IAAM,mBAAmB,KAAwB,cAAgC;CAC/E,MAAM,OAAiB;EACrB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,KAAK,UAAU,EAAE,YAAY,EAAE,YAAY;GAAE,MAAM;GAAQ,KAAK;EAAU,EAAE,EAAE,CAAC;EAC/E;CACF;CAIA,IAAI,IAAI,aAAa,SAAS,GAC5B,KAAK,KACH,kBACA,IAAI,aAAa,KAAK,SAAS,oBAAoB,MAAM,EAAE,KAAK,GAAG,CACrE;CAEF,IAAI,IAAI,uBAAuB,KAAA,GAC7B,KAAK,KAAK,0BAA0B,IAAI,kBAAkB;CAE5D,IAAI,IAAI,UAAU,KAAA,GAChB,KAAK,KAAK,WAAW,IAAI,KAAK;CAEhC,IAAI,IAAI,WAAW,KAAA,KAAa,IAAI,OAAO,SAAS,GAClD,KAAK,KAAK,aAAa,GAAG,IAAI,MAAM;CAEtC,IAAI,IAAI,iBAAiB,KAAA,GACvB,KAAK,KAAK,oBAAoB,OAAO,IAAI,YAAY,CAAC;CAGxD,KAAK,KAAK,eAAe,GAAG;CAC5B,IAAI,IAAI,kBAAkB,KAAA,KAAa,IAAI,cAAc,SAAS,GAIhE,KAAK,KAAK,oBAAoB,IAAI,cAAc,KAAK,GAAG,CAAC;CAE3D,IAAI,IAAI,wBAAwB,MAC9B,KAAK,KAAK,yBAAyB;CAErC,KAAK,MAAM,SAAS,IAAI,aAAa,CAAC,GACpC,KAAK,KAAK,GAAG,eAAe,KAAK,CAAC;CAEpC,KAAK,KAAK,MAAM,IAAI,MAAM;CAC1B,OAAO;AACT;;AAGA,IAAM,kBAAkB,QAA+D;CACrF,MAAM,MAA0C,EAAE,GAAG,QAAQ,IAAI;CACjE,OAAO,IAAI;CACX,OAAO,IAAI;CACX,OAAO,IAAI;CACX,OAAO,IAAI;CACX,OAAO,IAAI;CACX,OAAO,IAAI;CACX,OAAO,IAAI;CACX,IAAI,IAAI,MAAM,WAAW,KAAA,GAAW,IAAI,oBAAoB,IAAI,KAAK;CACrE,IAAI,IAAI,MAAM,cAAc,KAAA,GAAW,IAAI,uBAAuB,IAAI,KAAK;CAC3E,IAAI,IAAI,MAAM,YAAY,KAAA,GAAW,IAAI,qBAAqB,IAAI,KAAK;CACvE,IAAI,IAAI,qBAAqB,MAAM,IAAI,oBAAoB;CAC3D,IAAI,IAAI,0BAA0B,MAAM,IAAI,0BAA0B;CACtE,IAAI,IAAI,+BAA+B,MAAM,IAAI,2CAA2C;CAC5F,IAAI,IAAI,yBAAyB,KAAA,GAC/B,IAAI,oCAAoC,OAAO,IAAI,oBAAoB;CAEzE,OAAO;AACT;AAIA,IAAM,OAAO,YAA2B;CACtC,IAAI;CACJ,IAAI;CACJ,IAAI,eAAe;CACnB,IAAI,YAAY;;CAGhB,MAAM,uBAAuB,WAAiC;EAC5D,IAAI,CAAC,cAAc,WAAW,QAAQ,KAAA,KAAa,WAAW,aAAa,MAAM;EACjF,IAAI;GACF,QAAQ,KAAK,CAAC,WAAW,KAAK,MAAM;EACtC,QAAQ,CAER;CACF;;CAGA,MAAM,wBAAwB,OAAO,YAAmC;EACtE,IAAI,CAAC,cAAc,WAAW,aAAa,QAAQ,WAAW,eAAe,MAAM;EAQnF,IAAI,CAAC,MAPgB,IAAI,SAAkB,YAAY;GACrD,MAAM,QAAQ,iBAAiB,QAAQ,KAAK,GAAG,OAAO;GACtD,YAAY,KAAK,cAAc;IAC7B,aAAa,KAAK;IAClB,QAAQ,IAAI;GACd,CAAC;EACH,CAAC,GAEC,oBAAoB,SAAS;CAEjC;;;;;;;;CASA,MAAM,sBAAsB,OAAO,mBAA0C;EAC3E,QAAQ,cAAc,+CAA+C;EACrE,IAAI,QAAQ,MAAM,OAAO,eAAe;EACxC,IAAI,QAAQ,MAAM,OAAO,gBAAgB;EACzC,MAAM,sBAAsB,cAAc;EAC1C,MAAM,WAAW,EAAE,MAAM,oBAAoB,CAAC,EAAE,YAAY,CAAC,CAAC;EAC9D,gBAAgB;CAClB;CAKA,IAAI;CACJ,MAAM,oBAA0B;EAC9B,gBAAgB,iBAAiB;GAC/B,oBAAoB,SAAS;GAC7B,QAAQ,WAAW;GACnB,QAAQ,KAAK,CAAC;EAChB,GAAG,GAAK;CACV;CACA,MAAM,uBAA6B;EACjC,IAAI,eAAe,aAAa,aAAa;EAC7C,gBAAgB,KAAA;CAClB;CAEA,MAAM,mBAAmB,OAAO,mBAA0C;EACxE,IAAI,cAAc;EAClB,eAAe;EACf,YAAY;EACZ,MAAM,oBAAoB,cAAc;EACxC,eAAe;EACf,QAAQ,WAAW;CAGrB;CAKA,IAAI,iBAAiB;CACrB,MAAM,iBAAuB;EAC3B,IAAI,gBAAgB;EACpB,iBAAiB;EACjB,oBAAyB,GAAK,EAC3B,WAAW,QAAQ,KAAK,CAAC,CAAC,EAC1B,YAAY,QAAQ,KAAK,CAAC,CAAC;CAChC;CACA,QAAQ,GAAG,WAAW,QAAQ;CAC9B,QAAQ,GAAG,UAAU,QAAQ;CAG7B,QAAQ,GAAG,cAAc;EACvB,oBAAoB,SAAS;CAC/B,CAAC;CAED,IAAI;CAEJ,MAAM,iBAAiB,YAAkC;EACvD,IAAI,QAAQ,SAAS,OAAO;GAC1B,IAAI,eAAe,KAAA,GAAW;IAC5B,IAAI,SAAS,yBAAyB,+CAA+C;IACrF;GACF;GACA,aAAa;GACb,UAAe,OAAO;GACtB;EACF;EACA,IAAI,QAAQ,SAAS,sBAAsB;GACzC,QAAQ,gBAAgB,QAAQ,WAAW,QAAQ,OAAO;GAC1D;EACF;EACA,IAAI,QAAQ,SAAS,YAAY;GAC/B,iBAAsB,aAAa,MAAQ,CAAC;GAC5C;EACF;CACF;CAEA,MAAM,gBAAgB,wBAAwC,QAAQ;EACpE,IAAI;EACJ,IAAI;GACF,UAAU,KAAK,MAAM,GAAG;EAC1B,QAAQ;GACN,IAAI,SAAS,qBAAqB,mDAAmD,EACnF,aAAa,IAAI,MAAM,GAAG,GAAG,EAC/B,CAAC;GACD;EACF;EACA,cAAc,OAAO;EACrB,OAAO;CACT,CAAC;CACD,qBAAqB,UAAU,cAAc,KAAK,KAAK;CACvD,yBAAyB,cAAc,IAAI;CAC3C,QAAQ,MAAM,GAAG,QAAQ,iBAAiB;CAC1C,QAAQ,MAAM,GAAG,OAAO,gBAAgB;CAQxC,IAAI;EACF,SAAS,MAAM,gBAAgB,WAAW,UAAU,SAAS;GAC3D,WAAgB;IAAE,MAAM;IAAqB;IAAW,MAAM;IAAU;GAAK,CAAC;EAChF,CAAC;CACH,SAAS,KAAK;EACZ,MAAM,WAAW;GACf,MAAM;GACN,SAAS;GAET,QAAQ,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;EACzD,CAAC,EAAE,YAAY,CAAC,CAAC;EACjB,QAAQ,WAAW;EACnB;CACF;CAEA,MAAM,WAAW,EAAE,MAAM,QAAQ,CAAC;CAElC,MAAM,YAAY,OAAO,YAA8C;EACrE,IAAI,CAAC,QAAQ;EACb,OAAO,gBAAgB,QAAQ,YAAY;EAG3C,MAAM,OAAO,gBAAgB,SAAS,oBADA,OAAO,KAAK,EACH;EAC/C,MAAM,MAAM,eAAe,OAAO;EAElC,aAAa,MAAM,QAAQ,WAAW,MAAM;GAC1C,KAAK,QAAQ;GACb;GACA,UAAU;GACV,OAAO;IAAC;IAAU;IAAQ;GAAM;EAClC,CAAC;EAED,IAAI;EAEJ,MAAM,iBAAiB,wBAAwB,QAAQ;GACrD,MAAM,OAAO,0BAA0B,GAAG;GAC1C,IAAI,SAAS,KAAA,GAAW;IACtB,IACE,SACA,yBACA,sDACA,EACE,aAAa,IAAI,MAAM,GAAG,GAAG,EAC/B,CACF;IACA;GACF;GACA,iBAAsB,IAAI;GAC1B,OAAO;EACT,CAAC;EACD,WAAW,QAAQ,GAAG,SAAS,UAAsB;GACnD,eAAe,KAAK,KAAK;EAC3B,CAAC;EAED,MAAM,mBAAmB,OACvB,SACkB;GAClB,IAAI,SAAS,KAAA,GAAW;GACxB,IAAI,KAAK,SAAS,YAAY,KAAK,YAAY,QAAQ;IACrD,MAAM,kBAAkB,MAAM,QAAQ,KAAK,WAAW,IAClD,KAAK,YACF,QAAQ,MAAM,EAAE,WAAW,YAAY,EAAE,SAAS,YAAY,EAC9D,KAAK,MAAM,EAAE,IAAI,IACpB,CAAC;IACL,MAAM,WAAW;KACf,MAAM;KACN,OAAO,KAAK;KACZ,OAAO,KAAK;KACZ,iBAAiB,gBAAgB,SAAS,IAAI,kBAAkB,KAAA;KAChE,KAAK;IACP,CAAC;IACD;GACF;GACA,IAAI,KAAK,SAAS,YAAY,KAAK,YAAY,aAAa;IAC1D,MAAM,WAAW;KACf,MAAM;KACN,SAAS,KAAK,WAAW;KACzB,YAAY,KAAK;KACjB,cAAc,KAAK;KACnB,aAAa,KAAK;KAClB,OAAO,KAAK;IACd,CAAC;IACD;GACF;GACA,IAAI,KAAK,SAAS,gBAAgB;IAChC,IAAI,KAAK,sBAAsB,QAAQ,wBAAwB,MAAM;IACrE,MAAM,QAAQ,4BAA4B,IAAI;IAC9C,IAAI,UAAU,KAAA,GAAW;KACvB,MAAM,KAAK,oBAAoB;KAC/B,mBAAmB;KACnB,MAAM,WAAW;MAAE,MAAM;MAAiB;MAAI;KAAM,CAAC;IACvD;IACA;GACF;GACA,IAAI,KAAK,SAAS,eAAe,KAAK,SAAS,QAAQ;IACrD,IAAI,KAAK,sBAAsB,QAAQ,wBAAwB,MAAM;IACrE,MAAM,OAAO,mBAAmB,IAAI;IACpC,IAAI,KAAK,SAAS,GAAG;KACnB,MAAM,KAAK,oBAAoB;KAM/B,MAAM,WAAW;MAAE,MAAM;MAAiB;MAAI,OADhC,qBAAqB,KAAA,IAAY,OAAO;MACD,YAAY;KAAK,CAAC;KACvE,mBAAmB;IACrB;IACA;GACF;GACA,IAAI,KAAK,SAAS,UAAU;IAC1B,YAAY;IACZ,MAAM,WAAW;KACf,MAAM;KACN,YAAY,KAAK;KACjB,WAAW,KAAK;KAChB,cAAc,KAAK;KACnB,OAAO,KAAK;KACZ,SAAS,KAAK,aAAa;KAC3B,SAAS,KAAK;KACd,YAAY,KAAK;KACjB,KAAK;IACP,CAAC;IACD,MAAM,iBAAiB,GAAK;GAC9B;EACF;EAEA,WAAW,GAAG,UAAU,QAAQ;GAC9B,WAAgB;IACd,MAAM;IACN,SAAS;IACT,QAAQ,IAAI;GACd,CAAC,EAAE,YAAY,CAAC,CAAC;EACnB,CAAC;EACD,WAAW,GAAG,SAAS,MAAM,WAAW;GACtC,IAAI,aAAa,cAAc;GAC/B,WAAgB;IACd,MAAM;IACN,SAAS,uBAAuB,OAAO,IAAI,EAAE,WAAW,OAAO,MAAM,EAAE;GACzE,CAAC,EAAE,YAAY,CAAC,CAAC;EACnB,CAAC;CACH;AACF;AAEA,KAAK,EAAE,OAAO,UAAmB;CAE/B,MAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;CACrE,QAAQ,OAAO,MAAM,kCAAkC,QAAQ,GAAG;CAClE,QAAQ,WAAW;AACrB,CAAC"}