@beechcms/core 0.8.0 → 0.9.0

package/dist/engine/seeds/seed-validation.js

@@ -0,0 +1,384 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+import { AUTOMATION_RESERVED_WORDS } from '../../automations/automations-grammar-words.js';
+import { SYSTEM_COLUMNS } from '../ddl/ddl.js';
+import { LOCALIZABLE_BRANCH_TYPES } from '../localization/localization.js';
+import { resolveClassification } from '../privacy/policies.js';
+import { sortSeedsByDependencies } from './seed-registry.js';
+import { tagOptionsIssues } from './tag-options.js';
+import { SQL_RESERVED_WORDS } from '../sql-reserved-words.js';
+const BRANCH_ID_RE = /^br_[A-Za-z0-9]+$/;
+/**
+ * Allowed charset for a branch alias. An alias becomes a raw SQL column name in
+ * CREATE TABLE / ADD COLUMN / CREATE INDEX and in SELECT/WHERE/ORDER BY clauses
+ * (see engine.ts), so it MUST be restricted to a safe identifier charset to
+ * prevent DDL/query injection. Exported so the seeds API rename route reuses the
+ * exact same guard — do not inline a divergent copy.
+ */
+export const BRANCH_ALIAS_RE = /^[a-z][a-zA-Z0-9_]*$/;
+/**
+ * Reason a branch alias is reserved, or `null` when free to use.
+ * Single source for seed validation and the branch rename route.
+ */
+export function reservedBranchAliasReason(alias) {
+    if (SYSTEM_COLUMNS.has(alias)) {
+        return `branch '${alias}' collides with reserved system column. ` +
+            `System columns (id, slug, status, created_at, updated_at) cannot be used as branch aliases.`;
+    }
+    if (AUTOMATION_RESERVED_WORDS.has(alias)) {
+        return `branch '${alias}' uses reserved alias. ` +
+            `This word is used by the automation template grammar.`;
+    }
+    if (SQL_RESERVED_WORDS.has(alias.toLowerCase())) {
+        return `branch '${alias}' uses SQL reserved keyword. ` +
+            `Please pick a different alias to prevent database errors.`;
+    }
+    return null;
+}
+/**
+ * Allowed charset for a seed slug identifier.
+ * Must consist solely of lowercase ASCII letters, digits, and underscores.
+ * Exported so route handlers and validation functions reuse the exact same guard.
+ */
+export const SEED_SLUG_RE = /^[a-z0-9_]+$/;
+export const SLUG_RE = SEED_SLUG_RE;
+/**
+ * Pure, console-free, throw-free validation of a seed set.
+ * The single seed being created/edited should be validated in the context of
+ * the full active set: call validateSeedDefinitions([...otherActiveSeeds, edited]).
+ */
+export function validateSeedDefinitions(seeds) {
+    const result = [];
+    // ── Fatal 1: missing or unknown relation targets ─────────────────────────
+    const slugSet = new Set(seeds.map(s => s.slug));
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (branch.type !== 'relation')
+                continue;
+            if (!branch.targetSeed) {
+                messages.push(`branch '${branch.alias}' is a relation and requires a targetSeed`);
+            }
+            else if (!slugSet.has(branch.targetSeed)) {
+                messages.push(`branch '${branch.alias}' targets unknown seed '${branch.targetSeed}'`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 2: multi-relation with SET NULL ────────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (branch.type === 'relation' && branch.multiple === true && branch.onDelete === 'SET NULL') {
+                messages.push(`Branch '${branch.alias}': multi-relations cannot use ON DELETE SET NULL. ` +
+                    `Use 'CASCADE' or 'RESTRICT'.`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 3: junction table name collisions / length ─────────────────────
+    {
+        const junctionNames = new Set();
+        for (const seed of seeds) {
+            const messages = [];
+            for (const branch of seed.branches) {
+                if (branch.type !== 'relation' || branch.multiple !== true)
+                    continue;
+                const name = `rel_${seed.slug}_${branch.alias}`;
+                if (name.length > 256) {
+                    messages.push(`Junction table name '${name}' exceeds 256 characters (${name.length})`);
+                }
+                if (junctionNames.has(name)) {
+                    messages.push(`Junction table name collision: '${name}' already used by another seed/branch`);
+                }
+                junctionNames.add(name);
+            }
+            if (messages.length > 0)
+                result.push({ slug: seed.slug, messages, fatal: true });
+        }
+    }
+    // ── Fatal 4: dependency cycles ────────────────────────────────────────────
+    const hasUnknownTargets = result.some(e => e.fatal);
+    if (!hasUnknownTargets) {
+        try {
+            sortSeedsByDependencies(seeds);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const cycleMatch = msg.match(/Cyclic dependency detected among seeds: (.*)/);
+            if (cycleMatch) {
+                const cycleSlugs = cycleMatch[1].split(', ');
+                for (const slug of cycleSlugs) {
+                    result.push({ slug, messages: [msg], fatal: true });
+                }
+            }
+            else {
+                result.push({ slug: '<graph>', messages: [msg], fatal: true });
+            }
+        }
+    }
+    // ── Fatal 5: branch id format / uniqueness ───────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        const idsInSeed = new Set();
+        for (const branch of seed.branches) {
+            if (!branch.id || !BRANCH_ID_RE.test(branch.id)) {
+                messages.push(`branch '${branch.alias}' has invalid id '${branch.id}'. Expected format ^br_[A-Za-z0-9]+$.`);
+            }
+            else if (idsInSeed.has(branch.id)) {
+                messages.push(`duplicate branch id '${branch.id}'`);
+            }
+            if (branch.id)
+                idsInSeed.add(branch.id);
+            // Alias becomes a raw SQL column name — reject anything outside the safe
+            // identifier charset before it can reach DDL/query string interpolation.
+            if (typeof branch.alias !== 'string' || !BRANCH_ALIAS_RE.test(branch.alias)) {
+                messages.push(`branch alias '${branch.alias}' is invalid. Expected format ${BRANCH_ALIAS_RE.source} ` +
+                    `(lowercase letter followed by alphanumeric characters or underscores).`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 6: reserved aliases ─────────────────────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            const reason = reservedBranchAliasReason(branch.alias);
+            if (reason)
+                messages.push(reason);
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 10: repeater sub-field constraints ─────────────────────────────
+    {
+        const REPEATER_DISALLOWED_SUBTYPES = new Set(['repeater', 'relation', 'file']);
+        for (const seed of seeds) {
+            const messages = [];
+            for (const branch of seed.branches) {
+                if (branch.type !== 'repeater')
+                    continue;
+                const subIds = new Set();
+                const subAliases = new Set();
+                for (const sub of branch.fields ?? []) {
+                    if (REPEATER_DISALLOWED_SUBTYPES.has(sub.type)) {
+                        messages.push(`branch '${branch.alias}': sub-field '${sub.alias}' has disallowed type '${sub.type}'. ` +
+                            `Repeater sub-fields cannot be 'repeater', 'relation', or 'file' in v1.`);
+                    }
+                    if (!sub.id || !BRANCH_ID_RE.test(sub.id)) {
+                        messages.push(`branch '${branch.alias}': sub-field '${sub.alias}' has invalid id '${sub.id}'. ` +
+                            `Expected format ^br_[A-Za-z0-9]+$.`);
+                    }
+                    else if (subIds.has(sub.id)) {
+                        messages.push(`branch '${branch.alias}': duplicate sub-field id '${sub.id}'`);
+                    }
+                    if (sub.id)
+                        subIds.add(sub.id);
+                    if (typeof sub.alias !== 'string' || !BRANCH_ALIAS_RE.test(sub.alias)) {
+                        messages.push(`branch '${branch.alias}': sub-field alias '${sub.alias}' is invalid. ` +
+                            `Expected format ${BRANCH_ALIAS_RE.source}.`);
+                    }
+                    else if (subAliases.has(sub.alias)) {
+                        messages.push(`branch '${branch.alias}': duplicate sub-field alias '${sub.alias}'`);
+                    }
+                    subAliases.add(sub.alias);
+                }
+            }
+            if (messages.length > 0)
+                result.push({ slug: seed.slug, messages, fatal: true });
+        }
+    }
+    // ── Warning 7: duplicate slug ─────────────────────────────────────────────
+    {
+        const slugsSeen = new Set();
+        for (const seed of seeds) {
+            const messages = [];
+            if (slugsSeen.has(seed.slug)) {
+                messages.push(`duplicate slug "${seed.slug}" — each seed must have a unique slug`);
+            }
+            slugsSeen.add(seed.slug);
+            if (messages.length > 0)
+                result.push({ slug: seed.slug, messages, fatal: false });
+        }
+    }
+    // ── Warning 8: duplicate branch alias within a seed ───────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        const aliasesSeen = new Set();
+        for (const branch of seed.branches) {
+            if (aliasesSeen.has(branch.alias)) {
+                messages.push(`duplicate branch alias "${branch.alias}"`);
+            }
+            aliasesSeen.add(branch.alias);
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: false });
+    }
+    // ── Fatal 9: displayNameAlias not in branches ───────────────────────────
+    for (const seed of seeds) {
+        const allAliases = new Set(seed.branches.map(b => b.alias));
+        if (!allAliases.has(seed.displayNameAlias)) {
+            result.push({
+                slug: seed.slug,
+                messages: [`displayNameAlias "${seed.displayNameAlias}" not found in branches`],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 11 / Warning 10: repeater cardinality bounds ───────────────────
+    {
+        for (const seed of seeds) {
+            const fatals = [];
+            const warnings = [];
+            for (const branch of seed.branches) {
+                const hasBounds = branch.minItems !== undefined || branch.maxItems !== undefined;
+                if (!hasBounds)
+                    continue;
+                if (branch.type !== 'repeater') {
+                    warnings.push(`branch '${branch.alias}': minItems/maxItems are ignored on type ` +
+                        `'${branch.type}' (repeater-only).`);
+                    continue;
+                }
+                for (const [key, val] of [['minItems', branch.minItems], ['maxItems', branch.maxItems]]) {
+                    if (val !== undefined && (!Number.isInteger(val) || val < 0)) {
+                        fatals.push(`branch '${branch.alias}': ${key} must be a non-negative integer (got ${val}).`);
+                    }
+                }
+                if (Number.isInteger(branch.minItems) && Number.isInteger(branch.maxItems) &&
+                    branch.minItems > branch.maxItems) {
+                    fatals.push(`branch '${branch.alias}': minItems (${branch.minItems}) must be <= maxItems (${branch.maxItems}).`);
+                }
+            }
+            if (fatals.length > 0)
+                result.push({ slug: seed.slug, messages: fatals, fatal: true });
+            if (warnings.length > 0)
+                result.push({ slug: seed.slug, messages: warnings, fatal: false });
+        }
+    }
+    // ── Fatal 12: displayNameAlias format validation ───────────────────────────
+    for (const seed of seeds) {
+        if (typeof seed.displayNameAlias !== 'string' || !BRANCH_ALIAS_RE.test(seed.displayNameAlias)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `displayNameAlias '${seed.displayNameAlias}' is invalid. Expected format ${BRANCH_ALIAS_RE.source} ` +
+                        `(lowercase letter followed by alphanumeric characters or underscores).`,
+                ],
+                fatal: true,
+            });
+        }
+        else if (SYSTEM_COLUMNS.has(seed.displayNameAlias)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `displayNameAlias '${seed.displayNameAlias}' collides with reserved system column. ` +
+                        `System columns (id, slug, status, created_at, updated_at) cannot be used as displayNameAlias.`,
+                ],
+                fatal: true,
+            });
+        }
+        else if (SQL_RESERVED_WORDS.has(seed.displayNameAlias.toLowerCase())) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `displayNameAlias '${seed.displayNameAlias}' uses SQL reserved keyword. ` +
+                        `Please pick a different alias to prevent database errors.`,
+                ],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 13: retentionDays validation ─────────────────────────────────────
+    for (const seed of seeds) {
+        if (seed.retentionDays !== undefined && (!Number.isInteger(seed.retentionDays) || seed.retentionDays <= 0)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `retentionDays must be a positive integer >= 1 (got ${seed.retentionDays}).`,
+                ],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 14: publicEdit validation ─────────────────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (branch.policies?.publicEdit !== undefined && typeof branch.policies.publicEdit !== 'boolean') {
+                messages.push(`branch '${branch.alias}': policies.publicEdit must be a boolean`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 15: seed slug format validation ─────────────────────────────────
+    for (const seed of seeds) {
+        if (typeof seed.slug !== 'string' || !SEED_SLUG_RE.test(seed.slug)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `slug '${seed.slug}' is invalid. Expected format ${SEED_SLUG_RE.source} ` +
+                        `(lowercase letters, numbers, and underscores only).`,
+                ],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 16: softDelete type validation ────────────────────────────────────
+    for (const seed of seeds) {
+        if (seed.softDelete !== undefined && typeof seed.softDelete !== 'boolean') {
+            result.push({
+                slug: seed.slug,
+                messages: [`softDelete must be a boolean (got ${typeof seed.softDelete}).`],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 17: field-level localization constraints ─────────────────────────
+    // A localized value is a readable locale dictionary. Encrypted or hashed storage turns it into an
+    // opaque blob: per-locale extraction would be meaningless and would break decryption. Repeater
+    // sub-fields are excluded by domain rule, whatever their type.
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (branch.localized !== undefined && typeof branch.localized !== 'boolean') {
+                messages.push(`branch '${branch.alias}': localized must be a boolean`);
+            }
+            else if (branch.localized === true) {
+                if (!LOCALIZABLE_BRANCH_TYPES.has(branch.type)) {
+                    messages.push(`branch '${branch.alias}': localized is only supported on text, richtext and json branches ` +
+                        `(got '${branch.type}').`);
+                }
+                else {
+                    const { classification, storage } = resolveClassification(branch);
+                    if (storage !== 'plain') {
+                        messages.push(`branch '${branch.alias}': localized cannot be combined with '${classification}' classification ` +
+                            `(values are stored ${storage === 'encrypt' ? 'encrypted' : 'hashed'}).`);
+                    }
+                }
+            }
+            for (const sub of branch.fields ?? []) {
+                if (sub.localized !== undefined && sub.localized !== false) {
+                    messages.push(`branch '${branch.alias}': sub-field '${sub.alias}' cannot be localized. ` +
+                        `Repeater sub-fields are never localized.`);
+                }
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 18: tags options / cardinality ───────────────────────────────────
+    for (const seed of seeds) {
+        const messages = seed.branches.flatMap(branch => tagOptionsIssues(branch));
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    return result;
+}
+/** Convenience: true iff no fatal issues. */
+export function isSeedSetValid(seeds) {
+    return validateSeedDefinitions(seeds).every(i => !i.fatal);
+}

package/dist/engine/seeds/seeds.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Seed Registry: configurazione degli schemi di contenuto.
+ * In v0.4.0 ogni Seed genera una tabella `content_{slug}` con colonne reali.
+ * `branch.alias` è il nome della colonna SQL.
+ */
+import type { Seed } from '../types.js';
+/**
+ * Registro globale dei Seed.
+ * In produzione, questo viene popolato dalle definizioni dell'utente.
+ */
+export declare const SEED_REGISTRY: Record<string, Seed>;
+/**
+ * Registra un set di Seed nel registro globale.
+ */
+export declare function registerSeeds(seeds: Seed[]): void;
+/**
+ * Ritorna il Seed per lo slug dato, o null se non esiste.
+ */
+export declare function getSeed(slug: string): Seed | null;
+//# sourceMappingURL=seeds.d.ts.map

package/dist/engine/seeds/seeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeds.d.ts","sourceRoot":"","sources":["../../../src/engine/seeds/seeds.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAM,CAAA;AAErD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,QAI1C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAEjD"}

package/dist/engine/seeds/seeds.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * Registro globale dei Seed.
+ * In produzione, questo viene popolato dalle definizioni dell'utente.
+ */
+export const SEED_REGISTRY = {};
+/**
+ * Registra un set di Seed nel registro globale.
+ */
+export function registerSeeds(seeds) {
+    seeds.forEach(seed => {
+        SEED_REGISTRY[seed.slug] = seed;
+    });
+}
+/**
+ * Ritorna il Seed per lo slug dato, o null se non esiste.
+ */
+export function getSeed(slug) {
+    return SEED_REGISTRY[slug] ?? null;
+}

package/dist/engine/seeds/tag-migration.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @module engine/tag-migration
+ * Data migration from the pre-0.9 tag/choice shapes to the closed-vocabulary `tags` contract.
+ *
+ * Before 0.9 a choice field was either `text` + `options` (a single value stored as a plain string)
+ * or `tags` + `options: string[]`. Since 0.9 `options` exists only on `tags` as `{ value, color }[]`,
+ * and every stored value is a JSON array. Databases holding the old shapes were rejected at boot with
+ * no way forward; this module computes the way forward.
+ *
+ * Everything here is pure: it plans from seed definitions and emits SQL text. Nothing is executed,
+ * so the same plan drives the CLI dry run, `--apply`, and the audit.
+ */
+import type { Seed } from '../types.js';
+import type { SchemaQueryExecutor } from '../introspection/introspection.js';
+/**
+ * Colors assigned, in declaration order, to legacy options that never carried one.
+ * Deterministic on purpose: re-running the plan yields the same definition.
+ */
+export declare const TAG_MIGRATION_PALETTE: readonly string[];
+/** What the plan does with one branch. */
+export type TagMigrationAction = 
+/** `text` + `options` becomes single-choice `tags`; stored strings are wrapped into arrays. */
+'text-to-tags'
+/** `tags` whose `options` are plain strings or carry invalid colors; stored values are untouched. */
+ | 'tags-options'
+/** Cannot be converted safely; a human must edit the seed. */
+ | 'manual';
+export interface TagMigrationStep {
+    seed: string;
+    /** Dotted path when the branch is nested in a repeater, otherwise the alias. */
+    alias: string;
+    action: TagMigrationAction;
+    /** One line, operator-facing. */
+    summary: string;
+    /** Non-fatal remarks (e.g. a full-text index that still covers the column). */
+    warnings: string[];
+}
+export interface TagMigrationPlan {
+    steps: TagMigrationStep[];
+    /** Rewritten definitions, only for seeds that changed. Seeds with a `manual` step are not rewritten. */
+    seeds: Seed[];
+}
+/** True when the plan has anything to report or do. */
+export declare function hasTagMigrationWork(plan: TagMigrationPlan): boolean;
+/** Steps a human must resolve. */
+export declare function manualTagSteps(plan: TagMigrationPlan): TagMigrationStep[];
+/**
+ * Computes what moving `seeds` to the 0.9 tags contract takes. Seeds that already comply produce no
+ * step and no rewritten definition, so a clean database yields an empty plan (the operation is idempotent).
+ */
+export declare function planTagMigration(seeds: readonly Seed[]): TagMigrationPlan;
+/**
+ * The statements that carry the plan out, in execution order: stored values first, then the seed
+ * definitions, then the registry-version bump that tells every isolate to rebuild its cached registry.
+ * Value wrapping touches the live table and, when drafts are on, the drafts table.
+ *
+ * `originals` are the definitions the plan was computed from (the physical tables are named after them).
+ */
+export declare function tagMigrationStatements(plan: TagMigrationPlan, originals: readonly Seed[]): string[];
+/** A stored value that is not in the (new) vocabulary of its branch. */
+export interface TagOrphan {
+    seed: string;
+    alias: string;
+    value: string;
+    rows: number;
+}
+/**
+ * Reads, before anything is changed, the stored values the new vocabulary would not contain. They are
+ * reported, never deleted or rewritten: the operator decides whether to add an option or fix the rows.
+ * Read-only (`SELECT` through the injected executor).
+ */
+export declare function findTagOrphans(executor: SchemaQueryExecutor, plan: TagMigrationPlan, originals: readonly Seed[]): Promise<TagOrphan[]>;
+//# sourceMappingURL=tag-migration.d.ts.map

package/dist/engine/seeds/tag-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-migration.d.ts","sourceRoot":"","sources":["../../../src/engine/seeds/tag-migration.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAU,IAAI,EAAa,MAAM,aAAa,CAAA;AAE1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAK5E;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAElD,CAAA;AAED,0CAA0C;AAC1C,MAAM,MAAM,kBAAkB;AAC5B,+FAA+F;AAC7F,cAAc;AAChB,qGAAqG;GACnG,cAAc;AAChB,8DAA8D;GAC5D,QAAQ,CAAA;AAEZ,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,kBAAkB,CAAA;IAC1B,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,gBAAgB,EAAE,CAAA;IACzB,wGAAwG;IACxG,KAAK,EAAE,IAAI,EAAE,CAAA;CACd;AAED,uDAAuD;AACvD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAEnE;AAED,kCAAkC;AAClC,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,CAEzE;AA2GD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,gBAAgB,CAuBzE;AAeD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,EAAE,CA2BnG;AAED,wEAAwE;AACxE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb;AAOD;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,mBAAmB,EAC7B,IAAI,EAAE,gBAAgB,EACtB,SAAS,EAAE,SAAS,IAAI,EAAE,GACzB,OAAO,CAAC,SAAS,EAAE,CAAC,CA2BtB"}