@canvas-digital/blog-sdk 2.0.0

package/dist/lib/data-transfer.js

@@ -0,0 +1,436 @@
+/**
+ * Shared serializers / parsers for Tools → Export / Import.
+ * Supported formats: json, xml, csv.
+ */
+const escXml = (value) => String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+const escCsv = (value) => {
+    const raw = value == null
+        ? ''
+        : typeof value === 'object'
+            ? JSON.stringify(value)
+            : String(value);
+    if (/[",\n\r]/.test(raw))
+        return `"${raw.replace(/"/g, '""')}"`;
+    return raw;
+};
+const flattenRef = (value) => {
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .map((item) => {
+        if (typeof item === 'string' || typeof item === 'number')
+            return String(item);
+        if (item && typeof item === 'object') {
+            const row = item;
+            return String(row.slug || row.name || row.id || '');
+        }
+        return '';
+    })
+        .filter(Boolean)
+        .join('|');
+};
+const POST_CSV_HEADERS = [
+    'recordType',
+    'title',
+    'slug',
+    'excerpt',
+    'status',
+    'visibility',
+    'allowComments',
+    'publishedAt',
+    'categories',
+    'tags',
+    'authors',
+    'content',
+];
+const MEDIA_CSV_HEADERS = [
+    'recordType',
+    'id',
+    'alt',
+    'filename',
+    'mimeType',
+    'filesize',
+    'width',
+    'height',
+    'url',
+];
+const COMMENT_CSV_HEADERS = [
+    'recordType',
+    'postSlug',
+    'authorName',
+    'authorEmail',
+    'body',
+    'status',
+    'createdAt',
+];
+const objectToXml = (tag, value, depth = 0) => {
+    const pad = '  '.repeat(depth);
+    if (value == null || value === '')
+        return `${pad}<${tag}/>`;
+    if (Array.isArray(value)) {
+        if (!value.length)
+            return `${pad}<${tag}/>`;
+        return value.map((item) => objectToXml(tag.replace(/s$/, '') || 'item', item, depth)).join('\n');
+    }
+    if (typeof value === 'object') {
+        const rows = Object.entries(value)
+            .map(([k, v]) => objectToXml(k, v, depth + 1))
+            .join('\n');
+        return `${pad}<${tag}>\n${rows}\n${pad}</${tag}>`;
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return `${pad}<${tag}>${value}</${tag}>`;
+    }
+    const text = String(value);
+    if (text.includes('<') || text.includes('&') || text.length > 120) {
+        return `${pad}<${tag}><![CDATA[${text}]]></${tag}>`;
+    }
+    return `${pad}<${tag}>${escXml(text)}</${tag}>`;
+};
+export const serializeTransfer = (bundle, format) => {
+    if (format === 'json')
+        return JSON.stringify(bundle, null, 2);
+    if (format === 'xml') {
+        const parts = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            `<export format="${escXml(bundle.format)}" version="${bundle.version}">`,
+            `  <exportedAt>${escXml(bundle.exportedAt || '')}</exportedAt>`,
+            `  <brand>${escXml(bundle.brand || '')}</brand>`,
+            `  <brandName>${escXml(bundle.brandName || '')}</brandName>`,
+            `  <type>${escXml(bundle.type || '')}</type>`,
+        ];
+        if (bundle.posts?.length) {
+            parts.push('  <posts>');
+            for (const post of bundle.posts)
+                parts.push(objectToXml('post', post, 2));
+            parts.push('  </posts>');
+        }
+        if (bundle.media?.length) {
+            parts.push('  <mediaItems>');
+            for (const item of bundle.media)
+                parts.push(objectToXml('media', item, 2));
+            parts.push('  </mediaItems>');
+        }
+        if (bundle.comments?.length) {
+            parts.push('  <comments>');
+            for (const item of bundle.comments)
+                parts.push(objectToXml('comment', item, 2));
+            parts.push('  </comments>');
+        }
+        parts.push('</export>');
+        return parts.join('\n');
+    }
+    // CSV — one table with recordType discriminator
+    const lines = [];
+    const headers = [
+        ...new Set([...POST_CSV_HEADERS, ...MEDIA_CSV_HEADERS, ...COMMENT_CSV_HEADERS]),
+    ];
+    lines.push(headers.join(','));
+    for (const post of bundle.posts ?? []) {
+        const row = {
+            recordType: 'post',
+            title: post.title,
+            slug: post.slug,
+            excerpt: post.excerpt,
+            status: post.status,
+            visibility: post.visibility,
+            allowComments: post.allowComments,
+            publishedAt: post.publishedAt,
+            categories: flattenRef(post.category),
+            tags: flattenRef(post.tags),
+            authors: flattenRef(post.authors),
+            content: typeof post.content === 'string' ? post.content : JSON.stringify(post.content ?? null),
+        };
+        lines.push(headers.map((h) => escCsv(row[h] ?? '')).join(','));
+    }
+    for (const item of bundle.media ?? []) {
+        const row = {
+            recordType: 'media',
+            id: item.id,
+            alt: item.alt,
+            filename: item.filename,
+            mimeType: item.mimeType,
+            filesize: item.filesize,
+            width: item.width,
+            height: item.height,
+            url: item.url,
+        };
+        lines.push(headers.map((h) => escCsv(row[h] ?? '')).join(','));
+    }
+    for (const item of bundle.comments ?? []) {
+        const row = {
+            recordType: 'comment',
+            postSlug: item.postSlug ?? item.post,
+            authorName: item.authorName,
+            authorEmail: item.authorEmail,
+            body: item.body,
+            status: item.status,
+            createdAt: item.createdAt,
+        };
+        lines.push(headers.map((h) => escCsv(row[h] ?? '')).join(','));
+    }
+    return lines.join('\n');
+};
+export const contentTypeFor = (format) => {
+    if (format === 'xml')
+        return 'application/xml; charset=utf-8';
+    if (format === 'csv')
+        return 'text/csv; charset=utf-8';
+    return 'application/json; charset=utf-8';
+};
+export const extensionFor = (format) => format;
+const parseCsvLine = (line) => {
+    const out = [];
+    let cur = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (inQuotes) {
+            if (ch === '"' && line[i + 1] === '"') {
+                cur += '"';
+                i += 1;
+            }
+            else if (ch === '"') {
+                inQuotes = false;
+            }
+            else {
+                cur += ch;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inQuotes = true;
+            continue;
+        }
+        if (ch === ',') {
+            out.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    out.push(cur);
+    return out;
+};
+const parseCsv = (text) => {
+    const lines = text
+        .replace(/^\uFEFF/, '')
+        .split(/\r?\n/)
+        .filter((l) => l.trim().length);
+    if (lines.length < 2) {
+        return { format: 'blog-portal-export', version: 1, posts: [], comments: [], media: [] };
+    }
+    const headers = parseCsvLine(lines[0]).map((h) => h.trim());
+    const posts = [];
+    const media = [];
+    const comments = [];
+    for (const line of lines.slice(1)) {
+        const cols = parseCsvLine(line);
+        const row = {};
+        headers.forEach((h, i) => {
+            row[h] = cols[i] ?? '';
+        });
+        const recordType = (row.recordType || '').toLowerCase();
+        if (recordType === 'media' || (!recordType && row.filename && row.url)) {
+            media.push({
+                id: row.id || undefined,
+                alt: row.alt || null,
+                filename: row.filename || null,
+                mimeType: row.mimeType || null,
+                filesize: row.filesize ? Number(row.filesize) : null,
+                width: row.width ? Number(row.width) : null,
+                height: row.height ? Number(row.height) : null,
+                url: row.url || null,
+            });
+            continue;
+        }
+        if (recordType === 'comment' || (!recordType && row.postSlug && row.authorName && row.body)) {
+            comments.push({
+                postSlug: row.postSlug,
+                authorName: row.authorName,
+                authorEmail: row.authorEmail || null,
+                body: row.body,
+                status: row.status || 'approved',
+                createdAt: row.createdAt || null,
+            });
+            continue;
+        }
+        // default / post
+        if (row.title || row.slug) {
+            let content = row.content || null;
+            if (typeof content === 'string' && content.trim().startsWith('{')) {
+                try {
+                    content = JSON.parse(content);
+                }
+                catch {
+                    /* keep string */
+                }
+            }
+            posts.push({
+                title: row.title,
+                slug: row.slug,
+                excerpt: row.excerpt || null,
+                status: row.status || 'draft',
+                visibility: row.visibility || 'public',
+                allowComments: row.allowComments !== 'false',
+                publishedAt: row.publishedAt || null,
+                category: row.categories
+                    ? row.categories.split('|').filter(Boolean).map((slug) => ({ slug, name: slug }))
+                    : [],
+                tags: row.tags
+                    ? row.tags.split('|').filter(Boolean).map((slug) => ({ slug, name: slug }))
+                    : [],
+                authors: row.authors
+                    ? row.authors.split('|').filter(Boolean).map((id) => ({ id }))
+                    : [],
+                content,
+            });
+        }
+    }
+    return {
+        format: 'blog-portal-export',
+        version: 1,
+        posts,
+        media,
+        comments,
+    };
+};
+const xmlText = (block, tag) => {
+    const cdata = new RegExp(`<${tag}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tag}>`, 'i').exec(block);
+    if (cdata)
+        return cdata[1];
+    const plain = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, 'i').exec(block);
+    return plain ? plain[1].trim() : '';
+};
+const xmlBlocks = (text, tag) => {
+    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'gi');
+    const out = [];
+    let m;
+    while ((m = re.exec(text)))
+        out.push(m[1]);
+    return out;
+};
+const parseXmlPost = (block) => {
+    const categoryBlocks = xmlBlocks(block, 'category');
+    const tagBlocks = xmlBlocks(block, 'tag');
+    const authorBlocks = xmlBlocks(block, 'author');
+    return {
+        title: xmlText(block, 'title'),
+        slug: xmlText(block, 'slug'),
+        excerpt: xmlText(block, 'excerpt') || null,
+        status: xmlText(block, 'status') || 'draft',
+        visibility: xmlText(block, 'visibility') || 'public',
+        allowComments: xmlText(block, 'allowComments') !== 'false',
+        publishedAt: xmlText(block, 'publishedAt') || null,
+        category: categoryBlocks.map((b) => ({
+            id: xmlText(b, 'id') || undefined,
+            name: xmlText(b, 'name') || undefined,
+            slug: xmlText(b, 'slug') || undefined,
+        })),
+        tags: tagBlocks.map((b) => ({
+            id: xmlText(b, 'id') || undefined,
+            name: xmlText(b, 'name') || undefined,
+            slug: xmlText(b, 'slug') || undefined,
+        })),
+        authors: authorBlocks.map((b) => ({
+            id: xmlText(b, 'id') || undefined,
+            name: xmlText(b, 'name') || undefined,
+        })),
+        content: (() => {
+            const raw = xmlText(block, 'content');
+            if (!raw)
+                return null;
+            if (raw.trim().startsWith('{')) {
+                try {
+                    return JSON.parse(raw);
+                }
+                catch {
+                    return raw;
+                }
+            }
+            return raw;
+        })(),
+    };
+};
+const parseXml = (text) => {
+    const posts = xmlBlocks(text, 'post').map(parseXmlPost);
+    const media = xmlBlocks(text, 'media').map((block) => ({
+        id: xmlText(block, 'id') || undefined,
+        alt: xmlText(block, 'alt') || null,
+        filename: xmlText(block, 'filename') || null,
+        mimeType: xmlText(block, 'mimeType') || null,
+        url: xmlText(block, 'url') || null,
+        width: xmlText(block, 'width') ? Number(xmlText(block, 'width')) : null,
+        height: xmlText(block, 'height') ? Number(xmlText(block, 'height')) : null,
+        filesize: xmlText(block, 'filesize') ? Number(xmlText(block, 'filesize')) : null,
+    }));
+    const comments = xmlBlocks(text, 'comment').map((block) => ({
+        postSlug: xmlText(block, 'postSlug') || xmlText(block, 'post'),
+        authorName: xmlText(block, 'authorName'),
+        authorEmail: xmlText(block, 'authorEmail') || null,
+        body: xmlText(block, 'body'),
+        status: xmlText(block, 'status') || 'approved',
+        createdAt: xmlText(block, 'createdAt') || null,
+    }));
+    return {
+        format: 'blog-portal-export',
+        version: 1,
+        brand: xmlText(text, 'brand') || null,
+        brandName: xmlText(text, 'brandName') || undefined,
+        type: xmlText(text, 'type') || undefined,
+        posts,
+        media,
+        comments,
+    };
+};
+export const detectFormat = (filename, content) => {
+    const lower = filename.toLowerCase();
+    if (lower.endsWith('.csv'))
+        return 'csv';
+    if (lower.endsWith('.xml'))
+        return 'xml';
+    if (lower.endsWith('.json'))
+        return 'json';
+    const trimmed = content.trim();
+    if (trimmed.startsWith('<'))
+        return 'xml';
+    if (trimmed.includes(',') && !trimmed.startsWith('{') && !trimmed.startsWith('['))
+        return 'csv';
+    return 'json';
+};
+export const parseTransfer = (content, format) => {
+    const resolved = format || detectFormat('', content);
+    if (resolved === 'csv')
+        return parseCsv(content);
+    if (resolved === 'xml')
+        return parseXml(content);
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) {
+        // Heuristic: comment rows vs post rows
+        const first = parsed[0];
+        if (first && (first.postSlug || (first.authorName && first.body && !first.title))) {
+            return { format: 'blog-portal-export', version: 1, comments: parsed };
+        }
+        return { format: 'blog-portal-export', version: 1, posts: parsed };
+    }
+    if (parsed && typeof parsed === 'object') {
+        const root = parsed;
+        return {
+            format: 'blog-portal-export',
+            version: Number(root.version || 1),
+            exportedAt: root.exportedAt,
+            brand: root.brand,
+            brandName: root.brandName,
+            type: root.type,
+            posts: Array.isArray(root.posts) ? root.posts : [],
+            media: Array.isArray(root.media) ? root.media : [],
+            comments: Array.isArray(root.comments) ? root.comments : [],
+        };
+    }
+    throw new Error('Unrecognized file contents.');
+};

package/dist/lib/default-author.d.ts

@@ -0,0 +1,12 @@
+import type { Payload } from 'payload';
+import type { User } from '../payload-types';
+/**
+ * Resolve (or bootstrap) the byline that belongs to the signed-in user for this
+ * brand. Prefers an author linked via `user`, then a name match, then creates
+ * a self-linked byline so new posts default to the logged-in writer.
+ */
+export declare const ensureDefaultAuthor: (payload: Payload, user: User, tenantId: string) => Promise<{
+    id: string;
+    name: string;
+} | null>;
+//# sourceMappingURL=default-author.d.ts.map

package/dist/lib/default-author.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-author.d.ts","sourceRoot":"","sources":["../../app/lib/default-author.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAE5C;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,OAAO,EAChB,MAAM,IAAI,EACV,UAAU,MAAM,KACf,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoD7C,CAAA"}

package/dist/lib/default-author.js

@@ -0,0 +1,57 @@
+/**
+ * Resolve (or bootstrap) the byline that belongs to the signed-in user for this
+ * brand. Prefers an author linked via `user`, then a name match, then creates
+ * a self-linked byline so new posts default to the logged-in writer.
+ */
+export const ensureDefaultAuthor = async (payload, user, tenantId) => {
+    if (!tenantId)
+        return null;
+    const userId = String(user.id);
+    const displayName = (user.name || user.email || 'Author').trim();
+    const linked = await payload.find({
+        collection: 'authors',
+        where: {
+            and: [{ tenant: { equals: tenantId } }, { user: { equals: userId } }],
+        },
+        limit: 1,
+        depth: 0,
+        pagination: false,
+        user,
+        overrideAccess: false,
+    });
+    if (linked.docs[0]) {
+        return { id: String(linked.docs[0].id), name: String(linked.docs[0].name) };
+    }
+    const byName = await payload.find({
+        collection: 'authors',
+        where: {
+            and: [{ tenant: { equals: tenantId } }, { name: { equals: displayName } }],
+        },
+        limit: 1,
+        depth: 0,
+        pagination: false,
+        user,
+        overrideAccess: false,
+    });
+    if (byName.docs[0]) {
+        return { id: String(byName.docs[0].id), name: String(byName.docs[0].name) };
+    }
+    try {
+        const created = (await payload.create({
+            collection: 'authors',
+            data: {
+                tenant: tenantId,
+                name: displayName,
+                user: userId,
+            },
+            // Contributors may not have author-create access; bootstrapping a
+            // self-linked byline is intentional so the writer is pre-selected.
+            overrideAccess: true,
+            user,
+        }));
+        return { id: String(created.id), name: String(created.name) };
+    }
+    catch {
+        return null;
+    }
+};

package/dist/lib/format-media.d.ts

@@ -0,0 +1,6 @@
+import type { Post } from '../payload-types';
+/** Uploaded or legacy URL for a video-format post. */
+export declare const resolveFormatVideoSrc: (post: Post) => string | null;
+/** Uploaded or legacy URL for an audio-format post. */
+export declare const resolveFormatAudioSrc: (post: Post) => string | null;
+//# sourceMappingURL=format-media.d.ts.map

package/dist/lib/format-media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-media.d.ts","sourceRoot":"","sources":["../../app/lib/format-media.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAMnD,sDAAsD;AACtD,eAAO,MAAM,qBAAqB,GAAI,MAAM,IAAI,KAAG,MAAM,GAAG,IAK3D,CAAA;AAED,uDAAuD;AACvD,eAAO,MAAM,qBAAqB,GAAI,MAAM,IAAI,KAAG,MAAM,GAAG,IAK3D,CAAA"}

package/dist/lib/format-media.js

@@ -0,0 +1,18 @@
+import { mediaUrl } from './seo';
+const asMedia = (value) => typeof value === 'object' && value !== null ? value : null;
+/** Uploaded or legacy URL for a video-format post. */
+export const resolveFormatVideoSrc = (post) => {
+    const uploaded = mediaUrl(asMedia(post.formatMeta?.videoMedia));
+    if (uploaded)
+        return uploaded;
+    const legacy = post.formatMeta?.videoUrl?.trim();
+    return legacy || null;
+};
+/** Uploaded or legacy URL for an audio-format post. */
+export const resolveFormatAudioSrc = (post) => {
+    const uploaded = mediaUrl(asMedia(post.formatMeta?.audioMedia));
+    if (uploaded)
+        return uploaded;
+    const legacy = post.formatMeta?.audioUrl?.trim();
+    return legacy || null;
+};

package/dist/lib/format.d.ts

@@ -0,0 +1,7 @@
+export declare const formatDate: (value: string | Date) => string;
+export declare const formatShortDate: (value?: string | Date | null) => string;
+export declare const formatDateTime: (value?: string | Date | null) => string;
+/** Compact relative label — same wording as the dashboard “Recently published” list. */
+export declare const relativeTime: (value?: string | Date | null) => string;
+export declare const isoDate: (value: string | Date) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/lib/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../app/lib/format.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,GAAG,IAAI,KAAG,MAMxB,CAAA;AAE1B,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,GAAG,IAAI,GAAG,IAAI,KAAG,MAQtD,CAAA;AAET,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,GAAG,IAAI,GAAG,IAAI,KAAG,MAWrD,CAAA;AAET,wFAAwF;AACxF,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,GAAG,IAAI,GAAG,IAAI,KAAG,MAQ3D,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,GAAG,IAAI,KAAG,MAAqC,CAAA"}

package/dist/lib/format.js

@@ -0,0 +1,43 @@
+/** Dates are rendered in a fixed locale so server and client output match exactly. */
+const asDate = (value) => (typeof value === 'string' ? new Date(value) : value);
+export const formatDate = (value) => new Intl.DateTimeFormat('en-GB', {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+    timeZone: 'UTC',
+}).format(asDate(value));
+export const formatShortDate = (value) => value
+    ? new Intl.DateTimeFormat('en-GB', {
+        day: 'numeric',
+        month: 'short',
+        year: 'numeric',
+        timeZone: 'UTC',
+    }).format(asDate(value))
+    : '—';
+export const formatDateTime = (value) => value
+    ? new Intl.DateTimeFormat('en-GB', {
+        day: 'numeric',
+        month: 'short',
+        year: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        timeZone: 'UTC',
+        hourCycle: 'h23',
+    }).format(asDate(value))
+    : '—';
+/** Compact relative label — same wording as the dashboard “Recently published” list. */
+export const relativeTime = (value) => {
+    if (!value)
+        return '—';
+    const days = Math.floor((Date.now() - asDate(value).getTime()) / 86400000);
+    if (days <= 0)
+        return 'today';
+    if (days === 1)
+        return 'yesterday';
+    if (days < 30)
+        return `${days}d ago`;
+    if (days < 365)
+        return `${Math.floor(days / 30)}mo ago`;
+    return `${Math.floor(days / 365)}y ago`;
+};
+export const isoDate = (value) => asDate(value).toISOString();

package/dist/lib/hero-post.d.ts

@@ -0,0 +1,24 @@
+import type { Post } from '../payload-types';
+export type HeroMedia = {
+    kind: 'image';
+    src: string;
+    alt: string;
+} | {
+    kind: 'video-file';
+    src: string;
+    poster?: string | null;
+} | {
+    kind: 'video-embed';
+    src: string;
+    poster?: string | null;
+};
+/** Resolve background media for a post hero (image, file video, or embed). */
+export declare const resolveHeroMedia: (post: Post) => HeroMedia | null;
+/** First published post on the page that has a usable hero image or video. */
+export declare const findHeroPost: (posts: Post[]) => Post | null;
+/** Every post on the current page that can drive the media hero slider. */
+export declare const findHeroPosts: (posts: Post[]) => Post[];
+export declare const postCategoryName: (post: Post) => string | null;
+/** Article detail hero — full-width media at social/OG 1200×630 without ambient autoplay. */
+export declare const resolveArticleHeroMedia: (post: Post) => HeroMedia | null;
+//# sourceMappingURL=hero-post.d.ts.map

package/dist/lib/hero-post.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hero-post.d.ts","sourceRoot":"","sources":["../../app/lib/hero-post.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAMnD,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAuDhE,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,GAAI,MAAM,IAAI,KAAG,SAAS,GAAG,IAYzD,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,YAAY,GAAI,OAAO,IAAI,EAAE,KAAG,IAAI,GAAG,IAKnD,CAAA;AAED,2EAA2E;AAC3E,eAAO,MAAM,aAAa,GAAI,OAAO,IAAI,EAAE,KAAG,IAAI,EACO,CAAA;AAEzD,eAAO,MAAM,gBAAgB,GAAI,MAAM,IAAI,KAAG,MAAM,GAAG,IAAiC,CAAA;AAExF,6FAA6F;AAC7F,eAAO,MAAM,uBAAuB,GAAI,MAAM,IAAI,KAAG,SAAS,GAAG,IAiBhE,CAAA"}