@next-buildr/payload 0.0.0-stage → 2.0.1

package/dist/data/schema-from-fields.js

@@ -0,0 +1,178 @@
+/** Fields the builder itself owns; they are never data for a binding. */
+const INTERNAL_FIELDS = new Set(['layout', 'buildrRevision', '_status']);
+/** A name that says the value is a credential, whatever the field config claims. */
+const SENSITIVE_NAME = /pass(word|phrase)|secret|token|salt|hash|api[-_]?key|otp|2fa|session|credential/i;
+/** Payload's own collections and the plugin's; the auth collections are excluded by `auth`. */
+const isInternalCollection = (slug) => slug.startsWith('payload-') || slug.startsWith('buildr-');
+/** Whether a collection may take part in the schema and in contexts at all: never the auth ones. */
+export const isExposedCollection = (collection) => !collection.auth && !isInternalCollection(collection.slug);
+/** Layout-only wrappers whose children are ordinary siblings of the parent. */
+const CONTAINERS = new Set(['row', 'collapsible']);
+/** A field with a name that the schema (and the context) may carry, or `undefined`. */
+function exposed(field) {
+    if (field.name === undefined || field.name === '')
+        return undefined;
+    if (INTERNAL_FIELDS.has(field.name) || SENSITIVE_NAME.test(field.name))
+        return undefined;
+    if (field.hidden === true)
+        return undefined;
+    // A field-level read rule may hide it from this very user; the schema is not user-specific.
+    if (field.access?.read !== undefined)
+        return undefined;
+    return field;
+}
+/**
+ * The named fields of `fields` a binding may reach, layout containers (`row`, `collapsible`, tabs)
+ * flattened; a named tab is a `group`. This is the allow-list both the schema and the context use.
+ */
+export function exposedFields(fields) {
+    const result = [];
+    for (const field of fields) {
+        if (CONTAINERS.has(field.type)) {
+            result.push(...exposedFields(field.fields ?? []));
+        }
+        else if (field.type === 'tabs') {
+            for (const tab of field.tabs ?? []) {
+                if (tab.name === undefined) {
+                    result.push(...exposedFields(tab.fields));
+                }
+                else {
+                    const named = exposed({ type: 'group', name: tab.name, fields: tab.fields });
+                    if (named !== undefined)
+                        result.push(named);
+                }
+            }
+        }
+        else {
+            const own = exposed(field);
+            if (own !== undefined)
+                result.push(own);
+        }
+    }
+    return result;
+}
+const stringLabel = (field) => typeof field.label === 'string' ? field.label : undefined;
+const optionValue = (option) => {
+    if (typeof option === 'string')
+        return option;
+    if (typeof option === 'object' && option !== null && 'value' in option) {
+        const value = option.value;
+        return typeof value === 'string' ? value : undefined;
+    }
+    return undefined;
+};
+const targetOf = (field) => typeof field.relationTo === 'string' ? field.relationTo : undefined;
+/** The slug a relation points at when it can be followed (a single, exposed target). */
+export function relationTarget(field, source) {
+    const slug = targetOf(field);
+    const collection = source.collections.find((candidate) => candidate.slug === slug);
+    return collection !== undefined && isExposedCollection(collection) ? collection.slug : undefined;
+}
+/** The `DataType` of a field, or `undefined` for a kind the MVP does not expose. */
+function typeOf(field, source, options, reached) {
+    const many = (type) => type !== undefined && field.hasMany === true ? { t: 'list', of: type } : type;
+    switch (field.type) {
+        case 'text':
+        case 'textarea':
+        case 'email':
+            return many({ t: 'string' });
+        case 'number':
+            return many({ t: 'number' });
+        case 'checkbox':
+            return { t: 'boolean' };
+        case 'date':
+            return { t: 'date' };
+        case 'select':
+        case 'radio': {
+            const values = (field.options ?? []).flatMap((option) => optionValue(option) ?? []);
+            return many({ t: 'enum', values });
+        }
+        case 'richText':
+            return { t: 'richText' };
+        case 'upload':
+            return many({ t: 'media' });
+        case 'relationship': {
+            const slug = relationTarget(field, source);
+            if (slug === undefined)
+                return undefined;
+            reached.add(slug);
+            return many({ t: 'ref', entity: options.contextNames[slug] ?? slug });
+        }
+        case 'group':
+            return { t: 'object', fields: fieldsToData(field.fields ?? [], source, options, reached) };
+        case 'array':
+            return {
+                t: 'list',
+                of: { t: 'object', fields: fieldsToData(field.fields ?? [], source, options, reached) },
+            };
+        default:
+            // blocks, json, point, code, join, ui, ...: not exposed in the MVP.
+            return undefined;
+    }
+}
+function fieldsToData(fields, source, options, reached) {
+    const result = {};
+    for (const field of exposedFields(fields)) {
+        const type = typeOf(field, source, options, reached);
+        if (type === undefined)
+            continue;
+        const label = stringLabel(field);
+        result[field.name] = { type, ...(label === undefined ? {} : { label }), nullable: true };
+    }
+    return result;
+}
+const STANDARD = {
+    id: { type: { t: 'string' } },
+    createdAt: { type: { t: 'date' } },
+    updatedAt: { type: { t: 'date' } },
+};
+const objectOf = (fields) => ({
+    type: { t: 'object', fields: { ...STANDARD, ...fields } },
+});
+const ROUTE = {
+    type: {
+        t: 'object',
+        fields: {
+            path: { type: { t: 'string' } },
+            locale: { type: { t: 'string' } },
+            params: {
+                type: { t: 'object', fields: { page: { type: { t: 'number' }, nullable: true } } },
+            },
+        },
+    },
+};
+/**
+ * The `DataSchema` of a collection's documents: the scopes `site` (when the site global exists),
+ * the collection's own context name, and `route`; plus one entity per relation target that can be
+ * reached (transitively). Auth collections (`users`), hidden fields and anything that looks like a
+ * credential are never included; a relation to them is dropped.
+ */
+export function schemaFromCollection(source, collection, options) {
+    const own = source.collections.find((candidate) => candidate.slug === collection);
+    if (own === undefined || !isExposedCollection(own))
+        return undefined;
+    const reached = new Set();
+    const entities = {};
+    const scopes = {};
+    const site = source.globals?.find((global) => global.slug === options.siteGlobal);
+    if (site !== undefined) {
+        scopes['site'] = {
+            type: { t: 'object', fields: fieldsToData(site.fields, source, options, reached) },
+        };
+    }
+    scopes[options.contextNames[collection] ?? collection] = objectOf(fieldsToData(own.fields, source, options, reached));
+    scopes['route'] = ROUTE;
+    // Every relation target becomes an entity; a target's own relations extend the worklist.
+    const done = new Set();
+    while (true) {
+        const next = [...reached].find((slug) => !done.has(slug));
+        if (next === undefined)
+            break;
+        done.add(next);
+        const target = source.collections.find((candidate) => candidate.slug === next);
+        if (target === undefined)
+            continue;
+        entities[options.contextNames[next] ?? next] = objectOf(fieldsToData(target.fields, source, options, reached));
+    }
+    return { scopes, entities };
+}

package/dist/data/where.d.ts

@@ -0,0 +1,53 @@
+import type { FilterNode, JsonValue } from '@next-buildr/core';
+import type { Where } from 'payload';
+import { type CollectionLike } from './schema-from-fields.ts';
+/**
+ * How a query field behaves in Payload's `where`, decided from the collection config:
+ * - `string` | `number` | `boolean` | `date` | `id`: scalars whose comparisons Payload evaluates
+ *   the way the `DataSource` contract wants (typed, missing never matches);
+ * - `unsafe`: anything else (lists, rich text, ...): Payload cannot decide it, so the condition is
+ *   evaluated in memory on the normalized items.
+ */
+export type FieldKind = 'string' | 'number' | 'boolean' | 'date' | 'id' | 'unsafe';
+export interface QueryField {
+    readonly kind: FieldKind;
+    /** May the value be missing (an optional field, or one behind an optional relation)? */
+    readonly nullable: boolean;
+    /** The path in Payload's `where` / `sort`. */
+    readonly payloadPath: string;
+}
+export interface IdType {
+    readonly kind: 'number' | 'text';
+}
+/**
+ * Resolves a query path (`title`, `seo.title`, `author.name`, `author.id`) against the collection.
+ * Groups and single relationships to exposed collections are walked; hidden, credential-like and
+ * unknown fields do not resolve (`undefined`), so they can never be queried.
+ */
+export declare function resolveQueryField(collections: readonly CollectionLike[], slug: string, path: string): QueryField | undefined;
+/** A condition compiled for Payload: always true, never true, or a `where` (`post`: a superset only). */
+export type Compiled = {
+    readonly c: 'true';
+    readonly post: boolean;
+} | {
+    readonly c: 'false';
+    readonly post: false;
+} | {
+    readonly c: 'where';
+    readonly where: Where;
+    readonly post: boolean;
+};
+/** Thrown for a field the site owner did not allow (or that cannot be queried at all). */
+export declare class QueryFieldError extends Error {
+}
+export interface WhereContext {
+    readonly collections: readonly CollectionLike[];
+    readonly source: string;
+    readonly allowed: readonly string[];
+    readonly id: IdType;
+}
+/** The field of a query path, or a `QueryFieldError` when it is not allowlisted or does not resolve. */
+export declare function queryFieldOf(context: WhereContext, path: string): QueryField;
+/** Compiles a filter tree; `false` results short-circuit, unsafe conditions widen and flag `post`. */
+export declare function compileWhere(node: FilterNode<JsonValue>, context: WhereContext): Compiled;
+//# sourceMappingURL=where.d.ts.map

package/dist/data/where.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"where.d.ts","sourceRoot":"","sources":["../../src/data/where.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EACL,KAAK,cAAc,EAIpB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;AAEnF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,wFAAwF;IACxF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC;CAClC;AA6BD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,SAAS,cAAc,EAAE,EACtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,UAAU,GAAG,SAAS,CAgDxB;AAED,yGAAyG;AACzG,MAAM,MAAM,QAAQ,GAChB;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC9C;IAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAgG3E,0FAA0F;AAC1F,qBAAa,eAAgB,SAAQ,KAAK;CAAG;AAE7C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,wGAAwG;AACxG,wBAAgB,YAAY,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAS5E;AAED,sGAAsG;AACtG,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,QAAQ,CAsBzF"}

package/dist/data/where.js

@@ -0,0 +1,210 @@
+import { exposedFields, isExposedCollection, } from './schema-from-fields.js';
+/** The field named `name` among `fields`, layout containers and unnamed tabs looked through. */
+const findField = (fields, name) => exposedFields(fields).find((field) => field.name === name);
+function classify(field) {
+    if (field.hasMany === true)
+        return 'unsafe';
+    switch (field.type) {
+        case 'text':
+        case 'textarea':
+        case 'email':
+        case 'select':
+        case 'radio':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'checkbox':
+            return 'boolean';
+        case 'date':
+            return 'date';
+        default:
+            return 'unsafe';
+    }
+}
+const isRequired = (field) => field.required === true || field.defaultValue !== undefined;
+/**
+ * Resolves a query path (`title`, `seo.title`, `author.name`, `author.id`) against the collection.
+ * Groups and single relationships to exposed collections are walked; hidden, credential-like and
+ * unknown fields do not resolve (`undefined`), so they can never be queried.
+ */
+export function resolveQueryField(collections, slug, path) {
+    const own = collections.find((collection) => collection.slug === slug);
+    if (own === undefined || !isExposedCollection(own))
+        return undefined;
+    const segments = path.split('.');
+    let fields = own.fields;
+    let nullable = false;
+    const payloadPath = [];
+    for (let index = 0; index < segments.length; index++) {
+        const segment = segments[index];
+        const last = index === segments.length - 1;
+        if (index === 0 && last && segment === 'id') {
+            return { kind: 'id', nullable: false, payloadPath: 'id' };
+        }
+        if (index === 0 && last && (segment === 'createdAt' || segment === 'updatedAt')) {
+            return { kind: 'date', nullable: false, payloadPath: segment };
+        }
+        if (segment === 'id' && index > 0 && last) {
+            // `author.id`: Payload's `where` addresses a relationship by the field itself.
+            return { kind: 'id', nullable, payloadPath: payloadPath.join('.') };
+        }
+        const field = findField(fields, segment);
+        if (field === undefined)
+            return undefined;
+        payloadPath.push(segment);
+        if (!isRequired(field))
+            nullable = true;
+        if (last) {
+            // A relationship is queried by `author.id` or a field behind it, never as a whole.
+            if (field.type === 'relationship' && field.hasMany !== true)
+                return undefined;
+            return { kind: classify(field), nullable, payloadPath: payloadPath.join('.') };
+        }
+        if (field.type === 'group') {
+            fields = field.fields ?? [];
+        }
+        else if (field.type === 'relationship' && field.hasMany !== true) {
+            const target = collections.find((collection) => collection.slug === field.relationTo);
+            if (target === undefined || !isExposedCollection(target))
+                return undefined;
+            fields = target.fields;
+            nullable = true;
+        }
+        else if (field.type === 'array') {
+            // Through a list: the values are many per document; leave it to the in-memory evaluation.
+            return { kind: 'unsafe', nullable: true, payloadPath: payloadPath.join('.') };
+        }
+        else {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+const TRUE = { c: 'true', post: false };
+const FALSE = { c: 'false', post: false };
+/** A condition Payload cannot decide: everything passes the database, the memory pass decides. */
+const SUPERSET = { c: 'true', post: true };
+const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+/** A date operand is safe for Payload only in the canonical form that sorts like the instant. */
+const isCanonicalDate = (value) => typeof value === 'string' && ISO.test(value) && !Number.isNaN(Date.parse(value));
+/** Whether `value` is an operand the kind can equal (typed, like the contract). */
+function accepts(kind, value, id) {
+    switch (kind) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'date':
+            return isCanonicalDate(value);
+        case 'id':
+            // Normalized items carry ids as strings, so only strings can equal one.
+            return typeof value === 'string' && (id.kind === 'text' || /^\d+$/.test(value));
+        case 'unsafe':
+            return false;
+    }
+}
+const idValue = (kind, value, id) => kind === 'id' && id.kind === 'number' && typeof value === 'string' ? Number(value) : value;
+const atPath = (path, condition) => ({ [path]: condition });
+const RANGE = {
+    gt: 'greater_than',
+    gte: 'greater_than_equal',
+    lt: 'less_than',
+    lte: 'less_than_equal',
+};
+function compileLeaf(field, op, value, id) {
+    const { kind, payloadPath: path } = field;
+    const wrap = (where, post = false) => ({ c: 'where', where, post });
+    const orMissing = (where) => field.nullable ? { or: [where, atPath(path, { exists: false })] } : where;
+    if (kind === 'unsafe')
+        return SUPERSET;
+    switch (op) {
+        case 'eq':
+            return accepts(kind, value, id)
+                ? wrap(atPath(path, { equals: idValue(kind, value, id) }))
+                : FALSE;
+        case 'neq':
+            return accepts(kind, value, id)
+                ? wrap(orMissing(atPath(path, { not_equals: idValue(kind, value, id) })))
+                : TRUE;
+        case 'in': {
+            if (!Array.isArray(value))
+                return FALSE;
+            const usable = value.filter((option) => accepts(kind, option, id));
+            return usable.length === 0
+                ? FALSE
+                : wrap(atPath(path, { in: usable.map((option) => idValue(kind, option, id)) }));
+        }
+        case 'nin': {
+            if (!Array.isArray(value))
+                return TRUE;
+            const usable = value.filter((option) => accepts(kind, option, id));
+            return usable.length === 0
+                ? TRUE
+                : wrap(orMissing(atPath(path, { not_in: usable.map((option) => idValue(kind, option, id)) })));
+        }
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            if (kind === 'boolean' || kind === 'id')
+                return SUPERSET;
+            return accepts(kind, value, id) ? wrap(atPath(path, { [RANGE[op]]: value })) : FALSE;
+        case 'exists':
+            if (value !== false)
+                return field.nullable ? wrap(atPath(path, { exists: true })) : TRUE;
+            return field.nullable ? wrap(atPath(path, { exists: false })) : FALSE;
+        case 'contains':
+            if (kind === 'number' || kind === 'boolean')
+                return FALSE;
+            if (typeof value !== 'string')
+                return FALSE;
+            // Payload's `contains` ignores case; the contract does not, so it only narrows here.
+            return kind === 'string' ? wrap(atPath(path, { contains: value }), true) : SUPERSET;
+        default:
+            return FALSE;
+    }
+}
+/** Thrown for a field the site owner did not allow (or that cannot be queried at all). */
+export class QueryFieldError extends Error {
+}
+/** The field of a query path, or a `QueryFieldError` when it is not allowlisted or does not resolve. */
+export function queryFieldOf(context, path) {
+    if (!context.allowed.includes(path)) {
+        throw new QueryFieldError(`The field "${path}" of "${context.source}" cannot be queried.`);
+    }
+    const field = resolveQueryField(context.collections, context.source, path);
+    if (field === undefined) {
+        throw new QueryFieldError(`The field "${path}" of "${context.source}" cannot be queried.`);
+    }
+    return field;
+}
+/** Compiles a filter tree; `false` results short-circuit, unsafe conditions widen and flag `post`. */
+export function compileWhere(node, context) {
+    if ('and' in node) {
+        const parts = node.and.map((child) => compileWhere(child, context));
+        if (parts.some((part) => part.c === 'false'))
+            return FALSE;
+        const wheres = parts.flatMap((part) => (part.c === 'where' ? [part.where] : []));
+        const post = parts.some((part) => part.post);
+        if (wheres.length === 0)
+            return { c: 'true', post };
+        return {
+            c: 'where',
+            where: wheres.length === 1 ? wheres[0] : { and: wheres },
+            post,
+        };
+    }
+    if ('or' in node) {
+        const parts = node.or.map((child) => compileWhere(child, context));
+        const post = parts.some((part) => part.post);
+        if (parts.some((part) => part.c === 'true'))
+            return { c: 'true', post };
+        const wheres = parts.flatMap((part) => (part.c === 'where' ? [part.where] : []));
+        if (wheres.length === 0)
+            return FALSE;
+        return { c: 'where', where: wheres.length === 1 ? wheres[0] : { or: wheres }, post };
+    }
+    return compileLeaf(queryFieldOf(context, node.field), node.op, node.value, context.id);
+}

package/dist/mcp/http-backend.d.ts

@@ -0,0 +1,35 @@
+import { type Theme } from '@next-buildr/core';
+import { type McpBackend } from '@next-buildr/mcp';
+export interface PayloadMcpBackendOptions {
+    /** Payload's API root of the site, e.g. `https://example.com/api`. */
+    readonly baseUrl: string;
+    /** A Payload API key of a dedicated, low-privilege user. It is only ever sent as a header. */
+    readonly apiKey: string;
+    /** The auth collection the key belongs to (default `users`). */
+    readonly collection?: string;
+    /**
+     * The builder collections to list when `listDocuments` is called without a `collection`
+     * (the API has no collection index). Without it such a call is refused as `invalid`.
+     */
+    readonly collections?: readonly string[];
+    /** The theme of the site; the builder API does not serve one, so the default theme unless set. */
+    readonly theme?: Theme;
+    /** Origin that `previewUrl` prefixes to the document's public path (default: the origin of `baseUrl`). */
+    readonly siteUrl?: string;
+    /** Per-request timeout (default 15 s). */
+    readonly timeoutMs?: number;
+    /** Retries of idempotent requests (GET) after a network error, 429, 502, 503 or 504 (default 2). */
+    readonly retries?: number;
+    /** Defaults to the global `fetch` (looked up per call). */
+    readonly fetch?: typeof globalThis.fetch;
+    /** Waits between retries; injectable for tests. */
+    readonly sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * The `McpBackend` of `@next-buildr/mcp` over the builder API of a site running the Payload plugin
+ * (docs/mcp.md#http-backend). Authenticates with a Payload API key; every response is checked
+ * against the contract and documents with `parseDocument`. Only GETs are retried. The API key is
+ * sent as a header only and is scrubbed from every message this backend produces.
+ */
+export declare function createPayloadMcpBackend(options: PayloadMcpBackendOptions): McpBackend;
+//# sourceMappingURL=http-backend.d.ts.map

package/dist/mcp/http-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-backend.d.ts","sourceRoot":"","sources":["../../src/mcp/http-backend.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,KAAK,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAWL,KAAK,UAAU,EAIhB,MAAM,kBAAkB,CAAC;AAkB1B,MAAM,WAAW,wBAAwB;IACvC,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,kGAAkG;IAClG,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,0GAA0G;IAC1G,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACzC,mDAAmD;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAqCD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,UAAU,CA+UrF"}