@payloadcms/plugin-mcp 4.0.0-internal.293e026 → 4.0.0-internal.2a3c3bc

package/dist/utils/getVirtualFieldNames.js

@@ -1,35 +0,0 @@
-import { fieldIsVirtual } from 'payload/shared';
-/**
- * Returns the names of all top-level virtual fields for a given collection slug.
- */ export function getCollectionVirtualFieldNames(config, slug) {
-    const collection = config.collections.find((c)=>c.slug === slug);
-    if (!collection) {
-        return [];
-    }
-    return collection.flattenedFields.filter((field)=>'name' in field && fieldIsVirtual(field)).map((field)=>field.name);
-}
-/**
- * Returns the names of all top-level virtual fields for a given global slug.
- */ export function getGlobalVirtualFieldNames(config, slug) {
-    const global = config.globals.find((g)=>g.slug === slug);
-    if (!global) {
-        return [];
-    }
-    return global.flattenedFields.filter((field)=>'name' in field && fieldIsVirtual(field)).map((field)=>field.name);
-}
-/**
- * Strips virtual field values from a data object given a list of virtual field names.
- */ export function stripVirtualFields(data, virtualFieldNames) {
-    if (virtualFieldNames.length === 0) {
-        return data;
-    }
-    const stripped = {
-        ...data
-    };
-    for (const name of virtualFieldNames){
-        delete stripped[name];
-    }
-    return stripped;
-}
-
-//# sourceMappingURL=getVirtualFieldNames.js.map

package/dist/utils/getVirtualFieldNames.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/getVirtualFieldNames.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport { fieldIsVirtual } from 'payload/shared'\n\n/**\n * Returns the names of all top-level virtual fields for a given collection slug.\n */\nexport function getCollectionVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {\n  const collection = config.collections.find((c) => c.slug === slug)\n\n  if (!collection) {\n    return []\n  }\n\n  return collection.flattenedFields\n    .filter((field) => 'name' in field && fieldIsVirtual(field))\n    .map((field) => (field as { name: string }).name)\n}\n\n/**\n * Returns the names of all top-level virtual fields for a given global slug.\n */\nexport function getGlobalVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {\n  const global = config.globals.find((g) => g.slug === slug)\n\n  if (!global) {\n    return []\n  }\n\n  return global.flattenedFields\n    .filter((field) => 'name' in field && fieldIsVirtual(field))\n    .map((field) => (field as { name: string }).name)\n}\n\n/**\n * Strips virtual field values from a data object given a list of virtual field names.\n */\nexport function stripVirtualFields(\n  data: Record<string, unknown>,\n  virtualFieldNames: string[],\n): Record<string, unknown> {\n  if (virtualFieldNames.length === 0) {\n    return data\n  }\n\n  const stripped = { ...data }\n\n  for (const name of virtualFieldNames) {\n    delete stripped[name]\n  }\n\n  return stripped\n}\n"],"names":["fieldIsVirtual","getCollectionVirtualFieldNames","config","slug","collection","collections","find","c","flattenedFields","filter","field","map","name","getGlobalVirtualFieldNames","global","globals","g","stripVirtualFields","data","virtualFieldNames","length","stripped"],"mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAE/C;;CAEC,GACD,OAAO,SAASC,+BAA+BC,MAAuB,EAAEC,IAAY;IAClF,MAAMC,aAAaF,OAAOG,WAAW,CAACC,IAAI,CAAC,CAACC,IAAMA,EAAEJ,IAAI,KAAKA;IAE7D,IAAI,CAACC,YAAY;QACf,OAAO,EAAE;IACX;IAEA,OAAOA,WAAWI,eAAe,CAC9BC,MAAM,CAAC,CAACC,QAAU,UAAUA,SAASV,eAAeU,QACpDC,GAAG,CAAC,CAACD,QAAU,AAACA,MAA2BE,IAAI;AACpD;AAEA;;CAEC,GACD,OAAO,SAASC,2BAA2BX,MAAuB,EAAEC,IAAY;IAC9E,MAAMW,SAASZ,OAAOa,OAAO,CAACT,IAAI,CAAC,CAACU,IAAMA,EAAEb,IAAI,KAAKA;IAErD,IAAI,CAACW,QAAQ;QACX,OAAO,EAAE;IACX;IAEA,OAAOA,OAAON,eAAe,CAC1BC,MAAM,CAAC,CAACC,QAAU,UAAUA,SAASV,eAAeU,QACpDC,GAAG,CAAC,CAACD,QAAU,AAACA,MAA2BE,IAAI;AACpD;AAEA;;CAEC,GACD,OAAO,SAASK,mBACdC,IAA6B,EAC7BC,iBAA2B;IAE3B,IAAIA,kBAAkBC,MAAM,KAAK,GAAG;QAClC,OAAOF;IACT;IAEA,MAAMG,WAAW;QAAE,GAAGH,IAAI;IAAC;IAE3B,KAAK,MAAMN,QAAQO,kBAAmB;QACpC,OAAOE,QAAQ,CAACT,KAAK;IACvB;IAEA,OAAOS;AACT"}

package/dist/utils/localAPIDefaults.d.ts

@@ -1,20 +0,0 @@
-import type { AuthorizedMCP } from '../types.js';
-/**
- * Returns the `user` and `overrideAccess` arguments every Payload local API call
- * should receive when initiated from an MCP request. Spread the result into the
- * call's arg object so the two pieces of caller state can't drift apart.
- *
- * @example
- * ```ts
- * await req.payload.create({
- *   collection: 'posts',
- *   data,
- *   ...localAPIDefaults(authorizedMCP),
- * })
- * ```
- */
-export declare const localAPIDefaults: (authorizedMCP: AuthorizedMCP) => {
-    overrideAccess: boolean;
-    user: AuthorizedMCP["user"];
-};
-//# sourceMappingURL=localAPIDefaults.d.ts.map

package/dist/utils/localAPIDefaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"localAPIDefaults.d.ts","sourceRoot":"","sources":["../../src/utils/localAPIDefaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,eAAe,aAAa,KAC3B;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAGvD,CAAA"}

package/dist/utils/localAPIDefaults.js

@@ -1,19 +0,0 @@
-/**
- * Returns the `user` and `overrideAccess` arguments every Payload local API call
- * should receive when initiated from an MCP request. Spread the result into the
- * call's arg object so the two pieces of caller state can't drift apart.
- *
- * @example
- * ```ts
- * await req.payload.create({
- *   collection: 'posts',
- *   data,
- *   ...localAPIDefaults(authorizedMCP),
- * })
- * ```
- */ export const localAPIDefaults = (authorizedMCP)=>({
-        overrideAccess: authorizedMCP.overrideAccess,
-        user: authorizedMCP.user
-    });
-
-//# sourceMappingURL=localAPIDefaults.js.map

package/dist/utils/localAPIDefaults.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/localAPIDefaults.ts"],"sourcesContent":["import type { AuthorizedMCP } from '../types.js'\n\n/**\n * Returns the `user` and `overrideAccess` arguments every Payload local API call\n * should receive when initiated from an MCP request. Spread the result into the\n * call's arg object so the two pieces of caller state can't drift apart.\n *\n * @example\n * ```ts\n * await req.payload.create({\n *   collection: 'posts',\n *   data,\n *   ...localAPIDefaults(authorizedMCP),\n * })\n * ```\n */\nexport const localAPIDefaults = (\n  authorizedMCP: AuthorizedMCP,\n): { overrideAccess: boolean; user: AuthorizedMCP['user'] } => ({\n  overrideAccess: authorizedMCP.overrideAccess,\n  user: authorizedMCP.user,\n})\n"],"names":["localAPIDefaults","authorizedMCP","overrideAccess","user"],"mappings":"AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMA,mBAAmB,CAC9BC,gBAC8D,CAAA;QAC9DC,gBAAgBD,cAAcC,cAAc;QAC5CC,MAAMF,cAAcE,IAAI;IAC1B,CAAA,EAAE"}

package/dist/utils/schemaConversion/buildToolInput.d.ts

@@ -1,29 +0,0 @@
-import type { StandardSchemaWithJSON } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-import type { JsonSchemaType } from '../../types.js';
-/**
- * Builds a create/update tool's `input`: a `data` field (the document's fields) plus controls like
- * `depth` and `draft`. Using just `z.fromJSONSchema(ourJSONSchema)` has a few problems which are mitigated
- * in this function. z.fromJSONSchema is both bigger and lossier (≈40% larger on the lexical schema).
- * Each example below is `what we publish` => `what a plain zod round-trip would publish instead`.
- *
- * @example
- * Bigger - zod inlines shared defs instead of keeping our `$ref`s (and adds junk integer bounds), so a
- * reused def is duplicated at every use:
- * `{ $ref: '#/$defs/author' }` => `{ type: 'object', properties: { id, name }, additionalProperties: false }`
- *
- * @example
- * Lossier - zod drops the `description` on `enum`/`const` fields:
- * `{ enum: ['draft', 'published'], description: 'Publish state' }` → `{ enum: ['draft', 'published'] }`
- */
-export declare const buildToolInput: <TControls extends z.ZodRawShape>({ controls, dataDescription, dataSchema, }: {
-    /** Tool options alongside `data` (depth, draft, where, …) as plain zod - inferred into `input`. */
-    controls: TControls;
-    dataDescription: string;
-    dataSchema: JsonSchemaType;
-}) => StandardSchemaWithJSON<{
-    data: Record<string, unknown>;
-} & Omit<z.output<z.ZodObject<{
-    data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-} & TControls extends infer T ? { -readonly [P in keyof T]: T[P]; } : never, z.core.$strip>>, "data">>;
-//# sourceMappingURL=buildToolInput.d.ts.map

package/dist/utils/schemaConversion/buildToolInput.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildToolInput.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/buildToolInput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAE1E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,SAAS,CAAC,CAAC,WAAW,EAAE,4CAI7D;IACD,mGAAmG;IACnG,QAAQ,EAAE,SAAS,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,UAAU,EAAE,cAAc,CAAA;CAC3B,KAkCM,sBAAsB,CACzB;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM;;4FAAe,EAAE,MAAM,CAAC,CAE5E,CAAA"}

package/dist/utils/schemaConversion/buildToolInput.js

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-/**
- * Builds a create/update tool's `input`: a `data` field (the document's fields) plus controls like
- * `depth` and `draft`. Using just `z.fromJSONSchema(ourJSONSchema)` has a few problems which are mitigated
- * in this function. z.fromJSONSchema is both bigger and lossier (≈40% larger on the lexical schema).
- * Each example below is `what we publish` => `what a plain zod round-trip would publish instead`.
- *
- * @example
- * Bigger - zod inlines shared defs instead of keeping our `$ref`s (and adds junk integer bounds), so a
- * reused def is duplicated at every use:
- * `{ $ref: '#/$defs/author' }` => `{ type: 'object', properties: { id, name }, additionalProperties: false }`
- *
- * @example
- * Lossier - zod drops the `description` on `enum`/`const` fields:
- * `{ enum: ['draft', 'published'], description: 'Publish state' }` → `{ enum: ['draft', 'published'] }`
- */ export const buildToolInput = ({ controls, dataDescription, dataSchema })=>{
-    // `sanitizeEntitySchema` already emits draft 2020-12 with `$defs`, which is what zod's `fromJSONSchema`
-    // and MCP clients both expect. Drop only the root `$schema` keyword, redundant once it's a sub-schema.
-    const { $schema: _schema, ...entitySchema } = dataSchema;
-    const schema = z.object({
-        data: z.fromJSONSchema(entitySchema),
-        ...controls
-    });
-    const standard = schema['~standard'];
-    return {
-        '~standard': {
-            ...standard,
-            jsonSchema: {
-                ...standard.jsonSchema,
-                input: (options)=>{
-                    // Start from zod's JSON Schema for the whole input, then replace its lossy `data` schema with
-                    // the sanitized entity schema. The entity's `$defs` move to the root so the `$ref`s resolve.
-                    const generated = standard.jsonSchema.input(options);
-                    const { $defs, ...entityBody } = entitySchema;
-                    generated.properties.data = {
-                        ...entityBody,
-                        description: dataDescription
-                    };
-                    if ($defs) {
-                        generated.$defs = $defs;
-                    } else {
-                        delete generated.$defs;
-                    }
-                    return generated;
-                }
-            }
-        }
-    };
-};
-
-//# sourceMappingURL=buildToolInput.js.map

package/dist/utils/schemaConversion/buildToolInput.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/buildToolInput.ts"],"sourcesContent":["import type { StandardSchemaWithJSON } from '@modelcontextprotocol/server'\n\nimport { z } from 'zod'\n\nimport type { JsonSchemaType } from '../../types.js'\n\n/**\n * Builds a create/update tool's `input`: a `data` field (the document's fields) plus controls like\n * `depth` and `draft`. Using just `z.fromJSONSchema(ourJSONSchema)` has a few problems which are mitigated\n * in this function. z.fromJSONSchema is both bigger and lossier (≈40% larger on the lexical schema).\n * Each example below is `what we publish` => `what a plain zod round-trip would publish instead`.\n *\n * @example\n * Bigger - zod inlines shared defs instead of keeping our `$ref`s (and adds junk integer bounds), so a\n * reused def is duplicated at every use:\n * `{ $ref: '#/$defs/author' }` => `{ type: 'object', properties: { id, name }, additionalProperties: false }`\n *\n * @example\n * Lossier - zod drops the `description` on `enum`/`const` fields:\n * `{ enum: ['draft', 'published'], description: 'Publish state' }` → `{ enum: ['draft', 'published'] }`\n */\nexport const buildToolInput = <TControls extends z.ZodRawShape>({\n  controls,\n  dataDescription,\n  dataSchema,\n}: {\n  /** Tool options alongside `data` (depth, draft, where, …) as plain zod - inferred into `input`. */\n  controls: TControls\n  dataDescription: string\n  dataSchema: JsonSchemaType\n}) => {\n  // `sanitizeEntitySchema` already emits draft 2020-12 with `$defs`, which is what zod's `fromJSONSchema`\n  // and MCP clients both expect. Drop only the root `$schema` keyword, redundant once it's a sub-schema.\n  const { $schema: _schema, ...entitySchema } = dataSchema as Record<string, unknown>\n\n  const schema = z.object({\n    data: z.fromJSONSchema(entitySchema as unknown as z.core.JSONSchema.JSONSchema),\n    ...controls,\n  })\n  const standard = (schema as unknown as StandardSchemaWithJSON)['~standard']\n\n  return {\n    '~standard': {\n      ...standard,\n      jsonSchema: {\n        ...standard.jsonSchema,\n        input: (options) => {\n          // Start from zod's JSON Schema for the whole input, then replace its lossy `data` schema with\n          // the sanitized entity schema. The entity's `$defs` move to the root so the `$ref`s resolve.\n          const generated = standard.jsonSchema.input(options)\n          const { $defs, ...entityBody } = entitySchema\n          ;(generated.properties as Record<string, unknown>).data = {\n            ...entityBody,\n            description: dataDescription,\n          }\n          if ($defs) {\n            generated.$defs = $defs as object\n          } else {\n            delete generated.$defs\n          }\n          return generated\n        },\n      },\n    },\n  } as StandardSchemaWithJSON<\n    { data: Record<string, unknown> } & Omit<z.output<typeof schema>, 'data'>\n  >\n}\n"],"names":["z","buildToolInput","controls","dataDescription","dataSchema","$schema","_schema","entitySchema","schema","object","data","fromJSONSchema","standard","jsonSchema","input","options","generated","$defs","entityBody","properties","description"],"mappings":"AAEA,SAASA,CAAC,QAAQ,MAAK;AAIvB;;;;;;;;;;;;;;CAcC,GACD,OAAO,MAAMC,iBAAiB,CAAkC,EAC9DC,QAAQ,EACRC,eAAe,EACfC,UAAU,EAMX;IACC,wGAAwG;IACxG,uGAAuG;IACvG,MAAM,EAAEC,SAASC,OAAO,EAAE,GAAGC,cAAc,GAAGH;IAE9C,MAAMI,SAASR,EAAES,MAAM,CAAC;QACtBC,MAAMV,EAAEW,cAAc,CAACJ;QACvB,GAAGL,QAAQ;IACb;IACA,MAAMU,WAAW,AAACJ,MAA4C,CAAC,YAAY;IAE3E,OAAO;QACL,aAAa;YACX,GAAGI,QAAQ;YACXC,YAAY;gBACV,GAAGD,SAASC,UAAU;gBACtBC,OAAO,CAACC;oBACN,8FAA8F;oBAC9F,6FAA6F;oBAC7F,MAAMC,YAAYJ,SAASC,UAAU,CAACC,KAAK,CAACC;oBAC5C,MAAM,EAAEE,KAAK,EAAE,GAAGC,YAAY,GAAGX;oBAC/BS,UAAUG,UAAU,CAA6BT,IAAI,GAAG;wBACxD,GAAGQ,UAAU;wBACbE,aAAajB;oBACf;oBACA,IAAIc,OAAO;wBACTD,UAAUC,KAAK,GAAGA;oBACpB,OAAO;wBACL,OAAOD,UAAUC,KAAK;oBACxB;oBACA,OAAOD;gBACT;YACF;QACF;IACF;AAGF,EAAC"}

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.d.ts

@@ -1,7 +0,0 @@
-import type { JsonSchemaType } from '../../types.js';
-/**
- * Removes virtual fields from a JSON Schema by name so they don't appear
- * in the generated MCP tool input schema.
- */
-export declare function removeVirtualFieldsFromSchema(schema: JsonSchemaType, virtualFieldNames: string[]): JsonSchemaType;
-//# sourceMappingURL=removeVirtualFieldsFromSchema.d.ts.map

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeVirtualFieldsFromSchema.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,cAAc,EACtB,iBAAiB,EAAE,MAAM,EAAE,GAC1B,cAAc,CAiBhB"}

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.js

@@ -1,20 +0,0 @@
-/**
- * Removes virtual fields from a JSON Schema by name so they don't appear
- * in the generated MCP tool input schema.
- */ export function removeVirtualFieldsFromSchema(schema, virtualFieldNames) {
-    if (virtualFieldNames.length === 0) {
-        return schema;
-    }
-    for (const name of virtualFieldNames){
-        delete schema?.properties?.[name];
-    }
-    if (Array.isArray(schema.required)) {
-        schema.required = schema.required.filter((field)=>!virtualFieldNames.includes(field));
-        if (schema.required.length === 0) {
-            delete schema.required;
-        }
-    }
-    return schema;
-}
-
-//# sourceMappingURL=removeVirtualFieldsFromSchema.js.map

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts"],"sourcesContent":["import type { JsonSchemaType } from '../../types.js'\n\n/**\n * Removes virtual fields from a JSON Schema by name so they don't appear\n * in the generated MCP tool input schema.\n */\nexport function removeVirtualFieldsFromSchema(\n  schema: JsonSchemaType,\n  virtualFieldNames: string[],\n): JsonSchemaType {\n  if (virtualFieldNames.length === 0) {\n    return schema\n  }\n\n  for (const name of virtualFieldNames) {\n    delete schema?.properties?.[name]\n  }\n\n  if (Array.isArray(schema.required)) {\n    schema.required = schema.required.filter((field) => !virtualFieldNames.includes(field))\n    if (schema.required.length === 0) {\n      delete schema.required\n    }\n  }\n\n  return schema\n}\n"],"names":["removeVirtualFieldsFromSchema","schema","virtualFieldNames","length","name","properties","Array","isArray","required","filter","field","includes"],"mappings":"AAEA;;;CAGC,GACD,OAAO,SAASA,8BACdC,MAAsB,EACtBC,iBAA2B;IAE3B,IAAIA,kBAAkBC,MAAM,KAAK,GAAG;QAClC,OAAOF;IACT;IAEA,KAAK,MAAMG,QAAQF,kBAAmB;QACpC,OAAOD,QAAQI,YAAY,CAACD,KAAK;IACnC;IAEA,IAAIE,MAAMC,OAAO,CAACN,OAAOO,QAAQ,GAAG;QAClCP,OAAOO,QAAQ,GAAGP,OAAOO,QAAQ,CAACC,MAAM,CAAC,CAACC,QAAU,CAACR,kBAAkBS,QAAQ,CAACD;QAChF,IAAIT,OAAOO,QAAQ,CAACL,MAAM,KAAK,GAAG;YAChC,OAAOF,OAAOO,QAAQ;QACxB;IACF;IAEA,OAAOP;AACT"}

package/dist/utils/schemaConversion/sanitizeEntitySchema.d.ts

@@ -1,15 +0,0 @@
-import type { JsonSchemaType } from '../../types.js';
-/**
- * Turns the JSON Schema that Payload generates for a collection or global into the input schema for
- * an MCP create/update tool. In short, it:
- *
- * - drops fields a client can't set (`id`, `createdAt`, the draft `_status`, …),
- * - rewrites Payload-specific field shapes (points, relationships) into plain JSON the model can fill,
- * - and shrinks the result so it's cheaper for the model to read,
- *
- * while keeping every node valid JSON Schema draft 2020-12. Each step below is tagged with why it runs -
- * **Correctness** (valid input the API accepts), **Size** (equivalence-preserving shrink), or **LLM
- * ergonomics** (easier for the model to read/fill) - and carries a before/after example on its definition.
- */
-export declare const sanitizeEntitySchema: (schema: JsonSchemaType) => JsonSchemaType;
-//# sourceMappingURL=sanitizeEntitySchema.d.ts.map

package/dist/utils/schemaConversion/sanitizeEntitySchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sanitizeEntitySchema.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/sanitizeEntitySchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,cAAc,KAAG,cA6B7D,CAAA"}