zudoku 0.0.0-zacd7778d → 0.0.0-zc17c4c22

package/src/lib/util/flattenAllOfProcessor.ts

@@ -0,0 +1,58 @@
+import { $RefParser } from "@apidevtools/json-schema-ref-parser";
+import type { Processor } from "../../config/validators/BuildSchema.js";
+import type { OpenAPIDocument } from "../oas/parser/index.js";
+import { flattenAllOf } from "./flattenAllOf.js";
+import { type RecordAny, traverse } from "./traverse.js";
+
+export const flattenAllOfProcessor: Processor = async ({ schema, file }) => {
+  try {
+    // Resolve refs once - creates a lookup table without modifying the schema
+    const parser = new $RefParser();
+    await parser.resolve(schema);
+    const $refs = parser.$refs;
+
+    const flattened = traverse(schema, (spec) => {
+      if (!spec || typeof spec !== "object" || Array.isArray(spec)) {
+        return spec;
+      }
+
+      const isSchemaObject =
+        "type" in spec ||
+        "properties" in spec ||
+        "allOf" in spec ||
+        "anyOf" in spec ||
+        "oneOf" in spec;
+
+      if (!isSchemaObject) return spec;
+
+      if ("allOf" in spec && Array.isArray(spec.allOf)) {
+        const resolvedAllOf = spec.allOf.map((item) => {
+          if (
+            item &&
+            typeof item === "object" &&
+            "$ref" in item &&
+            typeof item.$ref === "string"
+          ) {
+            try {
+              return $refs.get(item.$ref) ?? item;
+            } catch {
+              return item;
+            }
+          }
+          return item;
+        });
+        return flattenAllOf({ ...spec, allOf: resolvedAllOf }) as RecordAny;
+      }
+
+      return flattenAllOf(spec) as RecordAny;
+    }) as OpenAPIDocument;
+
+    return flattened;
+  } catch (error) {
+    // biome-ignore lint/suspicious/noConsole: Logging allowed here
+    console.warn(
+      `Failed to flatten \`allOf\` in ${file}: ${error instanceof Error ? error.message : error}`,
+    );
+    return schema;
+  }
+};

package/src/lib/util/readFrontmatter.ts

@@ -9,5 +9,6 @@ export const yaml = {
 
 export const readFrontmatter = async (filePath: string) => {
   const content = await readFile(filePath, "utf-8");
-  return matter(content, { engines: { yaml } });
+  const normalizedContent = content.replace(/\r\n/g, "\n");
+  return matter(normalizedContent, { engines: { yaml } });
 };

package/src/shiki/langs/c3.js

@@ -0,0 +1 @@
+export { default } from "@shikijs/langs/c3";

package/src/shiki/langs/gn.js

@@ -0,0 +1 @@
+export { default } from "@shikijs/langs/gn";

package/src/shiki/langs/moonbit.js

@@ -0,0 +1 @@
+export { default } from "@shikijs/langs/moonbit";

package/src/zuplo/enrich-with-zuplo-mcp.ts

@@ -0,0 +1,168 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type {
+  ExtensionMcpServer,
+  ExtensionMcpServerTool,
+} from "@zuplo/mcp/openapi/types";
+import {
+  DEFAULT_MCP_SERVER_NAME,
+  DEFAULT_MCP_SERVER_VERSION,
+} from "@zuplo/mcp/server";
+import type { OpenAPIV3_1 } from "openapi-types";
+import type { ProcessorArg } from "../config/validators/BuildSchema.js";
+import { traverse, traverseAsync } from "../lib/util/traverse.js";
+import type { RecordAny } from "../lib/util/types.js";
+import { operations } from "./enrich-with-zuplo.js";
+
+// extracts x-mcp-server metadata from the operation using x-zuplo-mcp-tool
+// as a first class citizen.
+const extractOperationSchema = (
+  operation: OpenAPIV3_1.OperationObject & RecordAny,
+): ExtensionMcpServerTool | null => {
+  if (!operation.operationId) return null;
+
+  // Check if tool is explicitly disabled
+  const mcpToolConfig = operation["x-zuplo-mcp-tool"];
+  if (mcpToolConfig?.enabled === false) {
+    return null;
+  }
+
+  const tool: ExtensionMcpServerTool = {
+    // Use custom name from x-zuplo-mcp-tool or fallback to operationId
+    name: mcpToolConfig?.name || operation.operationId,
+
+    // Use custom description from x-zuplo-mcp-tool or fallback
+    // to operation description
+    description:
+      mcpToolConfig?.description ||
+      operation.summary ||
+      operation.description ||
+      `Operation ${operation.operationId}`,
+  };
+
+  // Grab valid request body JSON schema for the tool
+  const requestBody = operation.requestBody as
+    | OpenAPIV3_1.RequestBodyObject
+    | undefined;
+
+  const schema = requestBody?.content?.["application/json"]?.schema;
+  if (schema && typeof schema === "object") {
+    // TODO: @jpmcb - Zuplo also supports in-path parameters and query parameters
+    // as MCP "inputSchema" arguments. In order to document full argument params,
+    // Zudoku will need to more intelligently parse these elements of an operation.
+    tool.inputSchema = { body: schema };
+  }
+
+  return tool;
+};
+
+// Builds a lookup map of operationId -> operation for efficient access
+const buildOperationLookup = (
+  document: OpenAPIV3_1.Document,
+): Map<string, OpenAPIV3_1.OperationObject> => {
+  const operationMap = new Map<string, OpenAPIV3_1.OperationObject>();
+
+  traverse(document, (node, path) => {
+    // Check if we're at a path item level (paths -> /some/path -> method)
+    // and validate it's in allowed operations
+    if (
+      !path ||
+      path.length < 2 ||
+      path[0] !== "paths" ||
+      !operations.includes(path[path.length - 1] as string)
+    ) {
+      return node;
+    }
+
+    if (node.operationId) {
+      operationMap.set(node.operationId, node);
+    }
+
+    return node;
+  });
+
+  return operationMap;
+};
+
+// Takes an OpenAPI document and returns the x-mcp-server tools list defined
+// by an MCP server's options.files[x].operationIds array.
+const findOperationsInDocument = (
+  document: OpenAPIV3_1.Document,
+  operationIds: string[],
+): ExtensionMcpServerTool[] => {
+  const tools: ExtensionMcpServerTool[] = [];
+  const operationLookup = buildOperationLookup(document);
+
+  operationIds.forEach((operationId) => {
+    const operation = operationLookup.get(operationId);
+    if (operation) {
+      const tool = extractOperationSchema(operation);
+      if (tool) {
+        tools.push(tool);
+      }
+    }
+  });
+
+  return tools;
+};
+
+// Enriches an OpenAPI schema with x-mcp-server data based on the Zuplo MCP server handler
+export const enrichWithZuploMcpServerData = ({
+  rootDir,
+}: {
+  rootDir: string;
+}) => {
+  return async ({ schema }: ProcessorArg) => {
+    if (!schema.paths) return schema;
+    const modifiedSchema = { ...schema };
+    if (!modifiedSchema?.paths) return modifiedSchema;
+
+    await traverseAsync(modifiedSchema, async (node, nodePath) => {
+      // Check if we're at a "post" operation (paths -> /some/path -> "post").
+      // HTTP MCP servers are only allow post operations.
+      if (!nodePath || nodePath.length !== 3 || nodePath[2] !== "post") {
+        return node;
+      }
+
+      const operation = node as RecordAny;
+      if (!operation?.["x-zuplo-route"]) return node;
+
+      const handler = operation["x-zuplo-route"]?.handler;
+      if (handler?.export !== "mcpServerHandler" || !handler.options?.files)
+        return node;
+
+      const tools: ExtensionMcpServerTool[] = [];
+
+      for (const fileConfig of handler.options.files) {
+        if (!fileConfig.path || !fileConfig.operationIds) continue;
+
+        const resolvedPath = path.resolve(rootDir, "../", fileConfig.path);
+        const fileContent = await fs.readFile(resolvedPath, "utf-8");
+        const document = JSON.parse(fileContent);
+
+        if (document) {
+          const fileTools = findOperationsInDocument(
+            document,
+            fileConfig.operationIds,
+          );
+
+          tools.push(...fileTools);
+        }
+      }
+
+      const mcpExtension: ExtensionMcpServer = {
+        name: DEFAULT_MCP_SERVER_NAME,
+        version: DEFAULT_MCP_SERVER_VERSION,
+      };
+
+      if (tools.length > 0) {
+        mcpExtension.tools = tools;
+      }
+
+      node["x-mcp-server"] = mcpExtension;
+      return node;
+    });
+
+    return modifiedSchema;
+  };
+};

package/src/zuplo/enrich-with-zuplo.ts

@@ -0,0 +1,254 @@
+import type { OpenAPIV3_1 } from "openapi-types";
+import type { ProcessorArg } from "../config/validators/BuildSchema.js";
+import { objectEntries } from "../lib/util/objectEntries.js";
+import type { RecordAny } from "../lib/util/traverse.js";
+import type {
+  PoliciesConfigFile,
+  PolicyConfigurationFragment,
+} from "./policy-types.js";
+
+const API_KEY_REPLACEMENT_STRING = "YOUR_KEY_HERE";
+
+const enrichWithApiKeyData = (
+  operationObject: RecordAny,
+  apiKeyPolicies: PolicyConfigurationFragment[],
+) => {
+  if (apiKeyPolicies.length === 0) {
+    return operationObject;
+  }
+
+  const firstPolicy = apiKeyPolicies[0];
+  const authorizationHeader =
+    (firstPolicy?.handler.options?.authHeader as string) || "Authorization";
+  const authorizationScheme = (firstPolicy?.handler.options?.authScheme ??
+    "Bearer") as string;
+  const authSchemeExample =
+    authorizationScheme !== ""
+      ? `${authorizationScheme} ${API_KEY_REPLACEMENT_STRING}`
+      : API_KEY_REPLACEMENT_STRING;
+
+  // Add API key header parameter
+  const apiKeyHeader: OpenAPIV3_1.ParameterObject = {
+    name: authorizationHeader,
+    in: "header",
+    required: true,
+    example: authSchemeExample,
+    schema: {
+      type: "string",
+    },
+    description: `The \`${authorizationHeader}\` header is used to authenticate with the API using your API key. Value is of the format \`${authSchemeExample}\`.`,
+  };
+
+  const parameters = operationObject.parameters || [];
+  if (
+    !parameters.some((param: RecordAny) => param.name === authorizationHeader)
+  ) {
+    operationObject.parameters = [apiKeyHeader, ...parameters];
+  }
+
+  // Add security scheme and requirement
+  const apiSecuritySchemeId = "api_key";
+  const apiKeySecurityRequirement = { [apiSecuritySchemeId]: [] };
+
+  if (!operationObject.security) {
+    operationObject.security = [apiKeySecurityRequirement];
+  } else if (
+    !operationObject.security.some((req: RecordAny) => req[apiSecuritySchemeId])
+  ) {
+    operationObject.security = [
+      apiKeySecurityRequirement,
+      ...operationObject.security,
+    ];
+  }
+
+  return operationObject;
+};
+
+const enrichWithRateLimitData = (
+  operationObject: RecordAny,
+  rateLimitPolicies: PolicyConfigurationFragment[],
+) => {
+  if (rateLimitPolicies.length === 0) {
+    return operationObject;
+  }
+
+  const shouldIncludeHeader = rateLimitPolicies.some(
+    (policy) => policy.handler.options?.headerMode !== "none",
+  );
+
+  if (!operationObject.responses) {
+    operationObject.responses = {};
+  }
+
+  if (!operationObject.responses["429"]) {
+    operationObject.responses["429"] = {
+      $ref: shouldIncludeHeader
+        ? "#/components/responses/RateLimitWithRetryAfter"
+        : "#/components/responses/RateLimitNoRetryAfter",
+    };
+  }
+
+  return operationObject;
+};
+
+// biome-ignore format: for readability
+export const operations = [
+  "get", "put", "post", "delete",
+  "options", "head", "patch", "trace",
+];
+
+const rateLimitingResponse: OpenAPIV3_1.ResponseObject = {
+  description: "Rate Limiting Response",
+  content: {
+    "application/json": {
+      schema: {
+        type: "object",
+        required: ["type", "title", "status"],
+        examples: [
+          {
+            type: "https://httpproblems.com/http-status/429",
+            title: "Too Many Requests",
+            status: 429,
+            instance: "/foo/bar",
+          },
+        ],
+        properties: {
+          type: {
+            type: "string",
+            example: "https://httpproblems.com/http-status/429",
+            description: "A URI reference that identifies the problem.",
+          },
+          title: {
+            type: "string",
+            example: "Too Many Requests",
+            description: "A short, human-readable summary of the problem.",
+          },
+          status: {
+            type: "number",
+            example: 429,
+            description: "The HTTP status code.",
+          },
+          instance: {
+            type: "string",
+            example: "/foo/bar",
+          },
+        },
+      },
+    },
+  },
+};
+
+const rateLimitingResponseWithHeader: OpenAPIV3_1.ResponseObject = {
+  ...rateLimitingResponse,
+  headers: {
+    "retry-after": {
+      description: "The number of seconds to wait before making a new request.",
+      schema: {
+        type: "integer",
+        example: 60,
+      },
+    },
+  },
+};
+
+export const enrichWithZuploData = ({
+  policiesConfig,
+}: {
+  policiesConfig: PoliciesConfigFile;
+}) => {
+  return ({ schema }: ProcessorArg) => {
+    if (!schema.paths) return schema;
+
+    let hasRateLimitPolicies = false;
+
+    for (const [, pathItem] of objectEntries<RecordAny>(schema.paths)) {
+      for (const method of operations) {
+        const operation = pathItem[method];
+        if (!operation?.["x-zuplo-route"]) continue;
+
+        const inboundPolicies = operation[
+          "x-zuplo-route"
+        ]?.policies?.inbound?.reduce((acc: string[], policyName: string) => {
+          const policy = policiesConfig.policies?.find(
+            ({ name }) => name === policyName,
+          );
+          if (!policy) return acc;
+
+          // Handle composite policies
+          if (policy.handler.export === "CompositeInboundPolicy") {
+            const childPolicies = policy.handler.options?.policies as
+              | string[]
+              | undefined;
+            return childPolicies ? [...acc, ...childPolicies] : acc;
+          }
+
+          return [...acc, policyName];
+        }, []);
+
+        if (!inboundPolicies) continue;
+
+        // Find API key policies
+        const apiKeyPolicies =
+          policiesConfig.policies?.filter(
+            (policy) =>
+              inboundPolicies.includes(policy.name) &&
+              (policy.handler.export === "ApiAuthKeyInboundPolicy" ||
+                policy.handler.export === "ApiKeyInboundPolicy") &&
+              !policy.handler.options
+                ?.disableAutomaticallyAddingKeyHeaderToOpenApi,
+          ) ?? [];
+
+        // Find rate limit policies
+        const rateLimitPolicies =
+          policiesConfig.policies?.filter(
+            (policy) =>
+              inboundPolicies.includes(policy.name) &&
+              (policy.handler.export === "RateLimitInboundPolicy" ||
+                policy.handler.export === "ComplexRateLimitInboundPolicy"),
+          ) ?? [];
+
+        if (rateLimitPolicies.length > 0) {
+          hasRateLimitPolicies = true;
+        }
+
+        // Apply enrichments directly to the operation
+        pathItem[method] = enrichWithApiKeyData(operation, apiKeyPolicies);
+        pathItem[method] = enrichWithRateLimitData(
+          pathItem[method],
+          rateLimitPolicies,
+        );
+      }
+    }
+
+    // Add security scheme if we have API key policies
+    if (
+      policiesConfig.policies?.some(
+        (policy) =>
+          policy.handler.export === "ApiAuthKeyInboundPolicy" ||
+          policy.handler.export === "ApiKeyInboundPolicy",
+      )
+    ) {
+      if (!schema.components) schema.components = {};
+      if (!schema.components.securitySchemes)
+        schema.components.securitySchemes = {};
+
+      if (!schema.components.securitySchemes.api_key) {
+        schema.components.securitySchemes.api_key = {
+          type: "http",
+          scheme: "bearer",
+        };
+      }
+    }
+
+    // Add rate limiting responses only if we found rate limiting policies
+    if (hasRateLimitPolicies) {
+      if (!schema.components) schema.components = {};
+      if (!schema.components.responses) schema.components.responses = {};
+      schema.components.responses.RateLimitNoRetryAfter = rateLimitingResponse;
+      schema.components.responses.RateLimitWithRetryAfter =
+        rateLimitingResponseWithHeader;
+    }
+
+    return schema;
+  };
+};

package/src/zuplo/policy-types.ts

@@ -0,0 +1,46 @@
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+
+export interface PoliciesConfigFile {
+  policies?: PolicyConfigurationFragment[];
+  corsPolicies?: CorsPolicyConfiguration[];
+}
+export interface PolicyConfigurationFragment {
+  name: string;
+  policyType: string;
+  handler: HandlerDefinition;
+  options?: {
+    [k: string]: unknown;
+  };
+}
+export interface HandlerDefinition {
+  module: string;
+  export: string;
+  options?: {
+    [k: string]: unknown;
+  };
+}
+export interface CorsPolicyConfiguration {
+  name: string;
+  allowCredentials?: boolean;
+  maxAge?: number;
+  allowedOrigins: string[] | string;
+  allowedMethods?:
+    | (
+        | "GET"
+        | "HEAD"
+        | "POST"
+        | "PUT"
+        | "DELETE"
+        | "CONNECT"
+        | "OPTIONS"
+        | "TRACE"
+        | "PATCH"
+      )[]
+    | string;
+  allowedHeaders?: string[] | string;
+  exposeHeaders?: string[] | string;
+}

package/src/zuplo/with-zuplo-processors.ts

@@ -0,0 +1,35 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ZuploEnv } from "../app/env.js";
+import type {
+  Processor,
+  ProcessorArg,
+} from "../config/validators/BuildSchema.js";
+import { removeExtensions } from "../lib/plugins/openapi/processors/removeExtensions.js";
+import { removeParameters } from "../lib/plugins/openapi/processors/removeParameters.js";
+import { removePaths } from "../lib/plugins/openapi/processors/removePaths.js";
+import { enrichWithZuploData } from "./enrich-with-zuplo.js";
+import { enrichWithZuploMcpServerData } from "./enrich-with-zuplo-mcp.js";
+
+export const getProcessors = async (rootDir: string): Promise<Processor[]> => {
+  const policiesConfig = JSON.parse(
+    await fs.readFile(path.join(rootDir, "../config/policies.json"), "utf-8"),
+  );
+
+  return [
+    removePaths({ shouldRemove: ({ operation }) => operation["x-internal"] }),
+    removeParameters({
+      shouldRemove: ({ parameter }) => parameter["x-internal"],
+    }),
+    enrichWithZuploData({ policiesConfig }),
+    enrichWithZuploMcpServerData({ rootDir }),
+    ({ schema }: ProcessorArg) => {
+      const url = ZuploEnv.serverUrl;
+      if (!url) return schema;
+      return { ...schema, servers: [{ url }] };
+    },
+    removeExtensions({ shouldRemove: (key) => key.startsWith("x-zuplo") }),
+  ];
+};
+
+export default getProcessors;

package/src/zuplo/with-zuplo.ts

@@ -0,0 +1,14 @@
+import type { ZudokuConfig } from "../config/validators/validate.js";
+
+/**
+ *  @deprecated `withZuplo` is no longer needed and will automatically be applied. It will be removed in a future version.
+ */
+const withZuplo = (config: ZudokuConfig): ZudokuConfig => {
+  // biome-ignore lint/suspicious/noConsole: Logging allowed here
+  console.warn(
+    "`withZuplo` is no longer needed and will automatically be applied. It will be removed in a future version.",
+  );
+  return config;
+};
+
+export default withZuplo;

package/lib/OasProvider-DSe-hk5Y.js

@@ -1,40 +0,0 @@
-import { j as s } from "./jsx-runtime-BzflLqGi.js";
-import { useMemo as v } from "react";
-import { O as f } from "./chunk-EPOLDU6W-C6C8jAwd.js";
-import { j } from "./ZudokuContext-BZB1TWdT.js";
-import { g as c, O as x, G as O } from "./index-BQB9hb6n.js";
-const y = ({
-  basePath: e,
-  version: n,
-  config: r,
-  client: a
-}) => {
-  const p = v(() => {
-    const { versions: i, labels: u } = c(r), o = n ?? i.at(0), m = Object.fromEntries(
-      i.map((t) => [
-        t,
-        { path: j(e, t), label: u[t] ?? t }
-      ])
-    );
-    return {
-      config: {
-        ...r,
-        version: o,
-        versions: m,
-        input: (() => {
-          if (!Array.isArray(r.input))
-            return r.input;
-          const t = o ? r.input.find((l) => l.path === o) : r.input[0];
-          if (!t)
-            throw new Error(`No input found for version: ${o}`);
-          return t.input;
-        })()
-      }
-    };
-  }, [r, e, n]);
-  return /* @__PURE__ */ s.jsx(x, { value: p, children: /* @__PURE__ */ s.jsx(O, { client: a, children: /* @__PURE__ */ s.jsx(f, {}) }) });
-};
-export {
-  y as OasProvider
-};
-//# sourceMappingURL=OasProvider-DSe-hk5Y.js.map

package/lib/OasProvider-DSe-hk5Y.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OasProvider-DSe-hk5Y.js","sources":["../src/lib/plugins/openapi/OasProvider.tsx"],"sourcesContent":["import { useMemo } from \"react\";\nimport { Outlet } from \"react-router\";\nimport { joinUrl } from \"../../util/joinUrl.js\";\nimport type { GraphQLClient } from \"./client/GraphQLClient.js\";\nimport { GraphQLProvider } from \"./client/GraphQLContext.js\";\nimport { OasConfigProvider } from \"./context.js\";\nimport type { OasPluginConfig } from \"./interfaces.js\";\nimport { getVersionMetadata } from \"./util/getRoutes.js\";\n\nexport const OasProvider = ({\n  basePath,\n  version,\n  config,\n  client,\n}: {\n  basePath: string;\n  version?: string;\n  config: OasPluginConfig;\n  client: GraphQLClient;\n}) => {\n  const value = useMemo(() => {\n    const { versions: availableVersions, labels } = getVersionMetadata(config);\n    const currentVersion = version ?? availableVersions.at(0);\n\n    const versionLinks = Object.fromEntries(\n      availableVersions.map((id) => [\n        id,\n        { path: joinUrl(basePath, id), label: labels[id] ?? id },\n      ]),\n    );\n\n    const resolveInput = (): string | (() => Promise<unknown>) => {\n      if (!Array.isArray(config.input)) {\n        return config.input;\n      }\n\n      const versionConfig = currentVersion\n        ? config.input.find((v) => v.path === currentVersion)\n        : config.input[0];\n\n      if (!versionConfig) {\n        throw new Error(`No input found for version: ${currentVersion}`);\n      }\n\n      return versionConfig.input;\n    };\n\n    return {\n      config: {\n        ...config,\n        version: currentVersion,\n        versions: versionLinks,\n        input: resolveInput(),\n      },\n    };\n  }, [config, basePath, version]);\n\n  return (\n    <OasConfigProvider value={value}>\n      <GraphQLProvider client={client}>\n        <Outlet />\n      </GraphQLProvider>\n    </OasConfigProvider>\n  );\n};\n"],"names":["OasProvider","basePath","version","config","client","value","useMemo","availableVersions","labels","getVersionMetadata","currentVersion","versionLinks","id","joinUrl","versionConfig","v","jsx","OasConfigProvider","GraphQLProvider","Outlet"],"mappings":";;;;;AASO,MAAMA,IAAc,CAAC;AAAA,EAC1B,UAAAC;AAAA,EACA,SAAAC;AAAA,EACA,QAAAC;AAAA,EACA,QAAAC;AACF,MAKM;AACJ,QAAMC,IAAQC,EAAQ,MAAM;AAC1B,UAAM,EAAE,UAAUC,GAAmB,QAAAC,EAAA,IAAWC,EAAmBN,CAAM,GACnEO,IAAiBR,KAAWK,EAAkB,GAAG,CAAC,GAElDI,IAAe,OAAO;AAAA,MAC1BJ,EAAkB,IAAI,CAACK,MAAO;AAAA,QAC5BA;AAAA,QACA,EAAE,MAAMC,EAAQZ,GAAUW,CAAE,GAAG,OAAOJ,EAAOI,CAAE,KAAKA,EAAA;AAAA,MAAG,CACxD;AAAA,IAAA;AAmBH,WAAO;AAAA,MACL,QAAQ;AAAA,QACN,GAAGT;AAAA,QACH,SAASO;AAAA,QACT,UAAUC;AAAA,QACV,QArBiB,MAAyC;AAC5D,cAAI,CAAC,MAAM,QAAQR,EAAO,KAAK;AAC7B,mBAAOA,EAAO;AAGhB,gBAAMW,IAAgBJ,IAClBP,EAAO,MAAM,KAAK,CAACY,MAAMA,EAAE,SAASL,CAAc,IAClDP,EAAO,MAAM,CAAC;AAElB,cAAI,CAACW;AACH,kBAAM,IAAI,MAAM,+BAA+BJ,CAAc,EAAE;AAGjE,iBAAOI,EAAc;AAAA,QACvB,GAOW;AAAA,MAAa;AAAA,IACtB;AAAA,EAEJ,GAAG,CAACX,GAAQF,GAAUC,CAAO,CAAC;AAE9B,SACEc,gBAAAA,EAAAA,IAACC,KAAkB,OAAAZ,GACjB,UAAAW,gBAAAA,EAAAA,IAACE,KAAgB,QAAAd,GACf,UAAAY,gBAAAA,EAAAA,IAACG,GAAA,CAAA,CAAO,EAAA,CACV,EAAA,CACF;AAEJ;"}