n8n 2.32.4 → 2.33.0

package/dist/blob-storage/types.d.ts

@@ -1,23 +0,0 @@
-export type StorageLocation = 'fs' | 's3' | 'az';
-export type ByteStoreKey = string;
-export interface ByteStore {
-    init?(): Promise<void>;
-    write(key: ByteStoreKey, body: Buffer, contentType?: string): Promise<number>;
-    read(key: ByteStoreKey): Promise<Buffer | null>;
-    delete(keys: ByteStoreKey[]): Promise<void>;
-}
-export type JsonEntry<Payload extends object> = Payload & {
-    version: number;
-};
-export type Stored<Ref> = Ref & {
-    storedAt: StorageLocation;
-};
-export interface JsonStoreOptions<Ref> {
-    byteStores: Partial<Record<StorageLocation, ByteStore>>;
-    version: number;
-    key: (ref: Ref) => string;
-    getId: (ref: Ref) => string;
-    createWriteError: (ref: Ref, cause: unknown) => Error;
-    createCorruptedError: (ref: Ref, cause: unknown) => Error;
-    reportError: (error: unknown) => void;
-}

package/dist/blob-storage/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/blob-storage/types.ts"],"names":[],"mappings":""}

package/dist/modules/agents/builder/interactive/llm-provider-defaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"llm-provider-defaults.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/interactive/llm-provider-defaults.ts"],"names":[],"mappings":";;;AAqBa,QAAA,qBAAqB,GAAuC;IACxE,YAAY,EAAE;QACb,QAAQ,EAAE,WAAW;QACrB,YAAY,EAAE,mBAAmB;KACjC;IACD,SAAS,EAAE;QACV,QAAQ,EAAE,QAAQ;QAClB,YAAY,EAAE,YAAY;KAC1B;IACD,aAAa,EAAE;QACd,QAAQ,EAAE,QAAQ;QAClB,YAAY,EAAE,gBAAgB;KAC9B;IACD,MAAM,EAAE;QACP,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,QAAQ;KACtB;IACD,OAAO,EAAE;QACR,QAAQ,EAAE,MAAM;QAChB,YAAY,EAAE,yBAAyB;KACvC;IACD,eAAe,EAAE;QAChB,QAAQ,EAAE,SAAS;QACnB,YAAY,EAAE,sBAAsB;KACpC;IACD,WAAW,EAAE;QACZ,QAAQ,EAAE,UAAU;QACpB,YAAY,EAAE,eAAe;KAC7B;IACD,SAAS,EAAE;QACV,QAAQ,EAAE,QAAQ;QAClB,YAAY,EAAE,gBAAgB;KAC9B;IACD,aAAa,EAAE;QACd,QAAQ,EAAE,YAAY;QACtB,YAAY,EAAE,6BAA6B;KAC3C;IACD,SAAS,EAAE;QACV,QAAQ,EAAE,QAAQ;QAClB,YAAY,EAAE,wCAAwC;KACtD;IACD,kBAAkB,EAAE;QACnB,QAAQ,EAAE,QAAQ;QAClB,YAAY,EAAE,6BAA6B;KAC3C;CACD,CAAC"}

package/dist/modules/agents/builder/skills/integrations.skill.d.ts

@@ -1,2 +0,0 @@
-import type { RuntimeSkill } from '@n8n/agents';
-export declare function integrationsSkill(): RuntimeSkill;

package/dist/modules/agents/builder/skills/integrations.skill.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.integrationsSkill = integrationsSkill;
-function integrationsSkill() {
-    return {
-        id: 'agent-builder-integrations',
-        name: 'Agent Builder Integrations',
-        description: 'Use when deciding whether Slack, Linear, Telegram, or another external platform should be a target-agent chat integration/trigger versus an MCP, node, or workflow tool, and when adding, changing, or removing chat integrations; not for built-in Build chat or Preview chat behavior.',
-        recommendedTools: [
-            'resolve_integration',
-            'list_integration_types',
-            'configure_channel',
-            'ask_questions',
-            'read_config',
-            'patch_config',
-        ],
-        allowedTools: [
-            'resolve_integration',
-            'list_integration_types',
-            'configure_channel',
-            'ask_questions',
-            'read_config',
-            'patch_config',
-            'write_config',
-            'load_skill',
-        ],
-        instructions: `\
-## Purpose
-
-Use this to decide whether the target agent needs an entry in \`integrations\`
-or an MCP, node, or workflow tool for an external product, then configure
-\`integrations\` only when the integration is the right surface.
-
-## Use when
-
-- The user asks to add, update, or remove entries in the target agent's
-  \`integrations\` array.
-- The user asks to connect the target agent to an external chat platform with
-  credentials.
-
-## Integration vs Callable Tool Decision
-
-Use an integration when the product is the agent's conversation or trigger
-surface: humans will mention, message, comment to, or resume the agent there,
-or the agent needs to respond in that same platform conversation context.
-
-Use an MCP, node, or workflow tool when the product is only something the agent
-operates on: searching records, creating tickets, updating objects, or sending a
-business-process notification while the conversation happens elsewhere.
-
-Examples:
-
-- Slack integration: the agent should be chatted with in Slack, respond in
-  Slack threads, DM users, message channels, add reactions, or render rich UI
-  to Slack users.
-- Linear integration: the agent should be triggered from Linear issues/comments,
-  understand the current Linear subject, or reply in the same Linear
-  conversation.
-- Linear callable tools: the agent is triggered from Slack, Preview, a task, or a
-  workflow and only needs to search/create/update Linear tickets via MCP or node
-  tools.
-
-## Workflow
-
-The \`integrations\` array controls how the target agent is triggered.
-
-### Chat Integrations
-
-- These are connected external chat platforms, not built-in Preview chat.
-- Call \`list_integration_types\` first.
-- Read the returned \`capabilities\`, \`useIntegrationWhen\`, and
-  \`useNodeToolWhen\` fields before deciding to add an integration.
-- Pick one returned \`type\` and pass it to \`configure_channel\` as
-  \`integrationType\`. ALWAYS use \`configure_channel\` for chat-channel
-  credentials — never \`ask_credential\` or a raw config write. The setup UI it
-  shows creates and persists the credential/connection itself; do not follow up
-  with \`patch_config\`/\`write_config\` to write the credential.
-- Preserve existing chat integrations unless the user asked to remove them.
-- To remove an existing chat integration, call \`read_config\` and inspect
-  \`config.integrations\`.
-- If exactly one existing integration matches the requested platform, remove
-  that entry with \`patch_config\` by index (or replace \`/integrations\` with a
-  filtered array when clearer).
-- If multiple existing integrations match the requested platform, ask which one
-  to remove before editing \`integrations\`.
-- Removing a chat integration means deleting its entry from
-  \`integrations[]\`. Do not call \`configure_channel\` to remove a channel.
-
-### Callable External Services
-
-When the product is not a chat/trigger integration, call \`resolve_integration\`
-with queries matching the requested service before loading MCP or node-tool
-skills.
-
-- If it returns \`kind: "mcp"\`, load \`agent-builder-mcp\` and follow the MCP
-  credential, verification, and config workflow.
-- If it returns \`kind: "node"\`, load \`agent-builder-node-tools\`, use the
-  returned node results with \`get_node_types\`, and ask for every required
-  credential.
-- Use workflow tools when the capability should come from an existing workflow
-  instead of a direct MCP or node tool.
-
-## Gotchas
-
-- Chat integration types must come from \`list_integration_types\`.
-- Do not add a chat integration just because the agent needs CRUD or notifications
-  for that product. Resolve the callable capability through \`resolve_integration\`
-  unless the product itself is the chat/trigger context.
-- For recurring or scheduled runs, create a task (\`create_tasks\`), not an
-  integration.
-- Omitting \`integrations\` from a config write preserves the current channels.
-  To remove one, write an explicit filtered array or remove the exact array
-  entry.
-
-## Verify
-
-- Connected chat integrations were set up through \`configure_channel\`, not
-  \`ask_credential\` or a manual config write.
-- The chosen integration matches \`useIntegrationWhen\`; otherwise resolve the
-  callable capability through \`resolve_integration\` and use MCP, node, or
-  workflow tools.
-- Generic non-chat external services were routed through \`resolve_integration\`
-  before MCP or node setup.
-- The final \`integrations\` array keeps unrelated integrations intact and
-  removes only the requested channel entries.`,
-    };
-}
-//# sourceMappingURL=integrations.skill.js.map

package/dist/modules/agents/builder/skills/integrations.skill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integrations.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/integrations.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE,4BAA4B;QAClC,WAAW,EACV,0RAA0R;QAC3R,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,wBAAwB;YACxB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAkG8B;KAC5C,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/mcp.skill.d.ts

@@ -1,2 +0,0 @@
-import type { RuntimeSkill } from '@n8n/agents';
-export declare function mcpSkill(): RuntimeSkill;

package/dist/modules/agents/builder/skills/mcp.skill.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mcpSkill = mcpSkill;
-const api_types_1 = require("@n8n/api-types");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const schema_text_serializer_1 = require("../../json-config/schema-text-serializer");
-const mcpServerSchemaText = (0, schema_text_serializer_1.jsonSchemaToCompactText)((0, zod_to_json_schema_1.zodToJsonSchema)(api_types_1.McpServerConfigSchema));
-function mcpSkill() {
-    return {
-        id: 'agent-builder-mcp',
-        name: 'Agent builder MCP servers',
-        description: 'Use when adding, removing, or updating MCP (Model Context Protocol) servers on the target agent.',
-        recommendedTools: [
-            'resolve_integration',
-            'ask_questions',
-            'ask_credential',
-            'verify_mcp_server',
-            'read_config',
-            'patch_config',
-        ],
-        allowedTools: [
-            'resolve_integration',
-            'search_mcp_servers',
-            'search_nodes',
-            'get_node_types',
-            'ask_credential',
-            'verify_mcp_server',
-            'ask_questions',
-            'read_config',
-            'patch_config',
-            'write_config',
-            'load_skill',
-        ],
-        instructions: `\
-## Purpose
-
-Use this to manage external MCP server connections in the target agent config.
-MCP servers expose external tool catalogs to the target agent over HTTP. They
-live on the top-level \`mcpServers\` array, and each entry maps 1:1 to a
-connected MCP server.
-
-## Use when:
-
-- \`resolve_integration\` returned \`kind: "mcp"\`.
-- The user explicitly asks to add or edit an MCP server.
-- The user provides or asks to configure a custom MCP server.
-
-## Workflow
-
-### Discovery and setup
-
-For a generic external-service request, \`resolve_integration\` must select the
-integration type before this skill is loaded. If no resolver result is
-available yet, call \`resolve_integration\` with queries matching the requested
-service. Resolve one requested service per call; use \`queries\` only for
-alternative search terms for that service.
-
-- If it returns \`kind: "node"\` for a generic service request, load
-  \`agent-builder-node-tools\` and continue with the returned node results. Stop
-  this MCP workflow.
-- If it returns \`kind: "node"\` but the user explicitly requested an MCP server,
-  do not silently substitute a node tool. Continue with manual MCP setup by
-  asking for the URL and transport/authentication decision through
-  \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`.
-- \`resolve_integration\` returns \`{ kind: "mcp", results: [...] }\` for MCP
-  matches. Never read server fields from the wrapper; select a result first:
-  - If \`results[]\` contains one entry, use it as \`selectedResult\`.
-  - If the request uniquely identifies one entry by \`name\` or \`title\`, use
-    that entry as \`selectedResult\`.
-  - If multiple candidates remain, call \`ask_questions\` with the candidate
-    titles and descriptions; never choose by array order. Use the chosen entry
-    as \`selectedResult\`. If \`ask_questions\` returns \`{ answered: false }\`,
-    stop MCP setup without selecting a server, asking for credentials, verifying
-    a connection, or mutating config. Do not re-present the question.
-- Use \`name\`, \`url\`, \`transport\`, \`authentication\`, \`credentialType\`,
-  \`tools\`, and optional \`metadata\` only from \`selectedResult\`.
-
-Follow these steps for the selected MCP result:
-
-1. Credential: call \`ask_credential\` with a short \`purpose\`, using
-   \`selectedResult.credentialType\` as \`credentialType\`. Never invent
-   credential IDs.
-2. Verify: call \`verify_mcp_server\` with the selected result's \`name\`, \`url\`,
-   \`transport\`, and \`authentication\`, plus the returned \`credentialId\` as
-   \`credential\` when authentication is required.
-3. Capability check: confirm the verified tool names and descriptions cover the
-   capability the user requested.
-4. Write config: call \`read_config\`, then \`patch_config\` to add the entry to
-   \`mcpServers[]\` using the patch pattern below.
-
-If verification succeeds but the tools do not cover the requested capability
-for a generic service request, load \`agent-builder-node-tools\`, call
-\`search_nodes\` with the same service queries, and continue with node setup. Do
-not add the MCP server merely because its registry entry matched.
-
-Full schema reference:
-
-${mcpServerSchemaText}
-
-### Credential flow
-
-- For \`bearerAuth\`, call \`ask_credential\` with
-  \`credentialType: "httpBearerAuth"\`.
-- For \`headerAuth\`, call \`ask_credential\` with
-  \`credentialType: "httpHeaderAuth"\`.
-- For \`multipleHeadersAuth\`, call \`ask_credential\` with
-  \`credentialType: "httpMultipleHeadersAuth"\`.
-- For \`mcpOAuth2Api\`, call \`ask_credential\` with
-  \`credentialType: "mcpOAuth2Api"\`.
-
-### Testing the connection
-
-Before writing to config, call \`verify_mcp_server\` with server \`name\`,
-\`url\`, \`transport\`, and (if applicable) the credential id from
-\`ask_credential\`.
-
-- Success returns \`{ ok: true, tools: [{ name, description }] }\`.
-- Use the returned tool list to populate \`toolFilter.tools\` or
-  \`approval.tools\` so the user does not need to type tool names manually.
-- Failure returns \`{ ok: false, error: "..." }\`.
-- If verification fails, explain the error and ask the user to check the URL
-  or credentials before proceeding.
-
-### Incomplete setup
-
-The user can skip the credential prompt, the URL question, or both. Never
-invent a credential ID or a placeholder URL to fill the gap, and never abort
-the server addition — always persist what is known and let the user finish
-setup later:
-
-- Credential skipped (\`ask_credential\` returned \`{ skipped: true }\`): omit
-  only the \`credential\` field.
-- URL skipped: persist \`url: ""\`.
-- Either case: skip \`verify_mcp_server\` (there is nothing to authenticate or
-  connect to), then \`read_config\` and \`patch_config\` the entry, preserving
-  every other known field — \`name\`, \`transport\`, \`authentication\`, an
-  already-selected credential, and registry \`metadata\`.
-
-### Selecting credentials
-
-When using a registry-backed server, always use the \`credentialType\` returned
-by \`selectedResult\`.
-
-For custom MCP servers, if credential type is unknown, ask the user which
-credential type to use (OAuth2, Bearer Token, Header Auth, Multiple Headers
-Auth, or None) via \`${api_types_1.ASK_QUESTIONS_TOOL_NAME}\`. Then map to:
-
-- \`bearerAuth\` -> \`ask_credential\` with \`credentialType: "httpBearerAuth"\`
-- \`headerAuth\` -> \`ask_credential\` with \`credentialType: "httpHeaderAuth"\`
-- \`multipleHeadersAuth\` -> \`ask_credential\` with
-  \`credentialType: "httpMultipleHeadersAuth"\`
-- \`mcpOAuth2Api\` -> \`ask_credential\` with \`credentialType: "mcpOAuth2Api"\`
-
-### Patch pattern
-
-1. Initialize the array if missing:
-   \`{ "op": "add", "path": "/mcpServers", "value": [] }\`
-2. Append each server:
-   \`{ "op": "add", "path": "/mcpServers/-", "value": { ... } }\`
-
-## Gotchas
-
-- Server \`name\` must be unique across \`mcpServers\` within an agent.
-- Never fabricate \`metadata.nodeTypeName\`.
-- When \`selectedResult\` includes \`metadata.nodeTypeName\`, include
-  \`metadata: { nodeTypeName: <selectedResult.metadata.nodeTypeName> }\` in the
-  entry so the UI can render the correct server form.
-- A registry match proves server availability, not support for the requested
-  capability; use the verified live tool list for that decision.`,
-    };
-}
-//# sourceMappingURL=mcp.skill.js.map

package/dist/modules/agents/builder/skills/mcp.skill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/mcp.skill.ts"],"names":[],"mappings":";;;AACA,8CAAgF;AAEhF,2DAAqD;AAErD,qFAAmF;AAEnF,MAAM,mBAAmB,GAAG,IAAA,gDAAuB,EAClD,IAAA,oCAAe,EAAC,iCAAqB,CAAgB,CACrD,CAAC;AAEF;IACC,OAAO;QACN,EAAE,EAAE,mBAAmB;QACvB,IAAI,EAAE,2BAA2B;QACjC,WAAW,EACV,kGAAkG;QACnG,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,eAAe;YACf,gBAAgB;YAChB,mBAAmB;YACnB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,oBAAoB;YACpB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,mBAAmB;YACnB,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8BV,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC3B,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAgDE,mCAAuB;;;;;;;;;;;;;;;;;;;;;;;iEAuBmB;KAC/D,CAAC;AACH,CAAC"}

package/dist/modules/agents/builder/skills/node-tools.skill.d.ts

@@ -1,2 +0,0 @@
-import type { RuntimeSkill } from '@n8n/agents';
-export declare function nodeToolsSkill(): RuntimeSkill;

package/dist/modules/agents/builder/skills/node-tools.skill.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeToolsSkill = nodeToolsSkill;
-function nodeToolsSkill() {
-    return {
-        id: 'agent-builder-node-tools',
-        name: 'Agent Builder Node Tools',
-        description: 'Use when resolve_integration returns kind: "node" or the user explicitly requests an n8n node-backed tool: search_nodes/get_node_types discovery, nodeParameters, node credential slots, $fromAI usage, or other n8n expressions.',
-        recommendedTools: [
-            'resolve_integration',
-            'search_nodes',
-            'get_node_types',
-            'ask_credential',
-            'read_config',
-            'patch_config',
-        ],
-        allowedTools: [
-            'resolve_integration',
-            'search_nodes',
-            'get_node_types',
-            'ask_credential',
-            'get_resource_locator_options',
-            'ask_questions',
-            'read_config',
-            'patch_config',
-            'write_config',
-            'load_skill',
-        ],
-        instructions: `\
-## Purpose
-
-Use this to discover, configure, and wire node tools into the target agent's
-\`tools[]\`, including \`nodeParameters\` and n8n expressions.
-
-## Workflow
-
-- For a generic external-service request, call \`resolve_integration\` before
-  node discovery unless a resolver result is already available.
-- If it returns \`kind: "mcp"\`, load \`agent-builder-mcp\` and stop this node-tool
-  workflow.
-- If it returns \`kind: "node"\`, use its returned node results and call
-  \`get_node_types\`; do not repeat the same search with \`search_nodes\`.
-- Call \`search_nodes\` directly only when the user explicitly requests an n8n
-  node, when refining node results, or when a verified MCP server lacks the
-  requested capability.
-- Never guess node type names.
-- Use the tool node id from discovery, usually ending in \`Tool\`.
-- Put fixed values in \`nodeParameters\`; use complete n8n expressions for values the agent should decide at runtime:
-  \`={{ $fromAI('url', 'The URL to inspect', 'string') }}\`.
-- For stable dynamic selectors, load \`agent-builder-resource-locators\` and
-  follow it.
-- Never write literal \`"$fromAI"\` or bare \`$fromAI\`; the node will treat it as the actual value.
-- Do not pipe AI-chosen fields through \`$json\`.
-- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
-- For each required credential slot, call \`ask_credential\` once before config mutation. Pass the node's credential key as \`credentialSlot\`. On success, copy the returned \`credentials\` object directly to \`node.credentials\`. If skipped, still add the tool and omit only that credential slot.
-
-## n8n Expressions
-
-Node tool parameters inside \`nodeParameters\` can use n8n expressions.
-Prefer \`$fromAI\` whenever the target agent should decide a value at runtime.
-Do not use \`$fromAI\` for stable resource IDs that the target agent cannot know
-at runtime, such as Linear \`teamId\`, project IDs, channel IDs, calendar IDs,
-database IDs, table IDs, or other dynamic "Name or ID" selectors. Resolve those
-with the \`agent-builder-resource-locators\` skill, \`ask_credential\`, and
-\`get_resource_locator_options\`; write the returned \`parameterValue\` into
-\`nodeParameters\`.
-
-- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('fieldName', 'What value to provide', 'string') }}\`
-- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('count', 'How many items', 'number') }}\`
-- \`={{ /*n8n-auto-generated-fromAI-override*/ $fromAI('enabled', 'Whether to enable this option', 'boolean') }}\`
-- \`={{ $now.toISO() }}\` for current date/time.
-- \`={{ $today }}\` for the start of today.
-
-Always wrap expressions in \`={{ }}\`. Never pipe AI-chosen node-tool fields
-through \`$json\`; use \`$fromAI\` for those fields instead.
-
-## Gotchas
-
-- Do not include \`inputSchema\` or \`toolDescription\` for node tools.
-- \`$fromAI(...)\` placeholders define the node tool input schema; do not add it manually.
-- Follow \`agent-builder-resource-locators\` for dynamic selector lookup,
-  credentials, and \`parameterValue\` handling.
-- If a required node-tool credential is skipped, add the tool and omit only that credential slot.
-
-## Verify
-
-- Node tools use discovered tool node ids and valid node parameters.`,
-    };
-}
-//# sourceMappingURL=node-tools.skill.js.map

package/dist/modules/agents/builder/skills/node-tools.skill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-tools.skill.js","sourceRoot":"","sources":["../../../../../src/modules/agents/builder/skills/node-tools.skill.ts"],"names":[],"mappings":";;;AAEA;IACC,OAAO;QACN,EAAE,EAAE,0BAA0B;QAC9B,IAAI,EAAE,0BAA0B;QAChC,WAAW,EACV,mOAAmO;QACpO,gBAAgB,EAAE;YACjB,qBAAqB;YACrB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,aAAa;YACb,cAAc;SACd;QACD,YAAY,EAAE;YACb,qBAAqB;YACrB,cAAc;YACd,gBAAgB;YAChB,gBAAgB;YAChB,8BAA8B;YAC9B,eAAe;YACf,aAAa;YACb,cAAc;YACd,cAAc;YACd,YAAY;SACZ;QACD,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA0DqD;KACnE,CAAC;AACH,CAAC"}