@crowdedkingdoms/crowdyjs 17.14.0-dev.1 → 18.0.1-dev.1

package/dist/kit/blueprints/liveops.js

@@ -1,170 +0,0 @@
-import { kitPolicyJson, toSnakeCase, trustedAuthorityFields, } from './core.js';
-/** Compute the type/function names a liveops blueprint (and its runtime helper) uses. */
-export function liveopsNames(typePrefix = '') {
-    const fnPrefix = typePrefix ? `${toSnakeCase(typePrefix)}_` : '';
-    return {
-        windowType: `${typePrefix}EventWindow`,
-        seasonType: `${typePrefix}SeasonDef`,
-        openWindowFn: `${fnPrefix}open_window`,
-        closeWindowFn: `${fnPrefix}close_window`,
-        activateSeasonFn: `${fnPrefix}activate_season`,
-    };
-}
-/**
- * Blueprint for **liveops** (matrix P4, P3): event windows, seasons, and
- * battle-pass composition — MODEL-FIRST (the coexistence policy):
- *
- * - `EventWindow` containers carry a `window_id`, an `active` flag, optional
- *   `opens_at_ms`/`closes_at_ms` timestamps, and an opaque `modifiers` JSON
- *   blob. Admin (or cron-automation) functions flip `active`; when both
- *   timestamps are set, the **liveops-scheduler compute engine** flips the
- *   flag itself and broadcasts the modifiers on the compute bus
- *   (`liveops_window_opened`/`closed`) for other engines to apply — spawn
- *   multipliers, weather locks, double gold.
- * - `SeasonDef` containers name a season (`season_id`, `active`,
- *   `starts_at_ms`/`ends_at_ms`) and its battle-pass composition: the
- *   `pass_track` is a progression-layer track name and `pass_features` a
- *   JSON array of feature gates unlocked per tier — a battle pass is a
- *   SEASON + PROGRESSION TRACK + FEATURE GATES, no new machinery.
- *
- * Runtime counterpart: `client.kit(appId).liveops`.
- */
-export function liveopsBlueprint(options = {}) {
-    const { typePrefix = '', adminAuthority = 'server' } = options;
-    const names = liveopsNames(typePrefix);
-    const trusted = trustedAuthorityFields(adminAuthority);
-    const propertyDefinitions = [
-        {
-            containerTypeName: names.windowType,
-            key: 'window_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: 'Stable id other systems reference (unique per app by convention).',
-        },
-        {
-            containerTypeName: names.windowType,
-            key: 'active',
-            valueType: 'bool',
-            defaultValueJson: 'false',
-            description: 'Live flag. Flipped by the admin functions, cron automations, or the liveops-scheduler engine (timestamp windows).',
-        },
-        {
-            containerTypeName: names.windowType,
-            key: 'opens_at_ms',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Optional epoch-ms open time (with closes_at_ms, the scheduler owns the flag).',
-        },
-        {
-            containerTypeName: names.windowType,
-            key: 'closes_at_ms',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Optional epoch-ms close time.',
-        },
-        {
-            containerTypeName: names.windowType,
-            key: 'modifiers',
-            valueType: 'string',
-            defaultValueJson: '"{}"',
-            description: 'Opaque JSON broadcast on the compute bus when the window opens/closes (consumed by engines).',
-        },
-        {
-            containerTypeName: names.seasonType,
-            key: 'season_id',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: 'Stable season id (e.g. "s3").',
-        },
-        {
-            containerTypeName: names.seasonType,
-            key: 'active',
-            valueType: 'bool',
-            defaultValueJson: 'false',
-            description: 'The one live season (activate_season deactivates the rest by convention).',
-        },
-        {
-            containerTypeName: names.seasonType,
-            key: 'starts_at_ms',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Season start (epoch ms; informational).',
-        },
-        {
-            containerTypeName: names.seasonType,
-            key: 'ends_at_ms',
-            valueType: 'int',
-            defaultValueJson: '0',
-            description: 'Season end (epoch ms; informational).',
-        },
-        {
-            containerTypeName: names.seasonType,
-            key: 'pass_track',
-            valueType: 'string',
-            defaultValueJson: '""',
-            description: "Battle-pass composition: the progression layer's track name whose tiers gate rewards.",
-        },
-        {
-            containerTypeName: names.seasonType,
-            key: 'pass_features',
-            valueType: 'string',
-            defaultValueJson: '"[]"',
-            description: 'Battle-pass composition: JSON array of feature-gate keys unlocked per pass tier.',
-        },
-    ];
-    const functions = [
-        {
-            name: names.openWindowFn,
-            containerTypeName: names.windowType,
-            returnType: 'bool',
-            mutations: [{ target: 'self', property: 'active', expression: 'true' }],
-            returnExpression: 'self.active',
-            invokePolicyJson: trusted.invokePolicyJson ?? kitPolicyJson({ type: 'is_automation' }),
-            ...(trusted.autonomousInvocable !== undefined
-                ? { autonomousInvocable: trusted.autonomousInvocable }
-                : {}),
-            description: 'Open the window (admin/automation). The liveops-scheduler engine broadcasts the modifiers on the next tick.',
-        },
-        {
-            name: names.closeWindowFn,
-            containerTypeName: names.windowType,
-            returnType: 'bool',
-            mutations: [{ target: 'self', property: 'active', expression: 'false' }],
-            returnExpression: 'self.active',
-            invokePolicyJson: trusted.invokePolicyJson ?? kitPolicyJson({ type: 'is_automation' }),
-            ...(trusted.autonomousInvocable !== undefined
-                ? { autonomousInvocable: trusted.autonomousInvocable }
-                : {}),
-            description: 'Close the window (admin/automation).',
-        },
-        {
-            name: names.activateSeasonFn,
-            containerTypeName: names.seasonType,
-            returnType: 'bool',
-            mutations: [{ target: 'self', property: 'active', expression: 'true' }],
-            returnExpression: 'self.active',
-            invokePolicyJson: trusted.invokePolicyJson ?? kitPolicyJson({ type: 'is_automation' }),
-            ...(trusted.autonomousInvocable !== undefined
-                ? { autonomousInvocable: trusted.autonomousInvocable }
-                : {}),
-            description: 'Activate this season (admin/automation). Deactivate the previous season separately (one live season by convention).',
-        },
-    ];
-    return {
-        name: 'liveops',
-        containerTypes: [
-            {
-                typeName: names.windowType,
-                displayName: 'Liveops event window',
-                description: 'A liveops window: active flag + optional timestamps + modifier JSON broadcast by the scheduler engine.',
-            },
-            {
-                typeName: names.seasonType,
-                displayName: 'Liveops season',
-                description: 'A season definition; battle passes compose a season with a progression track + feature gates.',
-            },
-        ],
-        propertyDefinitions,
-        functions,
-    };
-}

package/dist/kit/blueprints/locks.d.ts

@@ -1,82 +0,0 @@
-import { type KitBlueprint, type KitInvokePolicy } from './core.js';
-/**
- * The authority source that may operate a lockable object. Several may be
- * combined (any one grants access — they are OR'd):
- *
- * - `owner` — only the container's owner (`owner_of_self`); "only the owner
- *   of this chest can open it".
- * - `key` — the caller must own a matching key item; "if a player has key 1
- *   they can open door 1". Adds a required `key_id` (`container_ref`) param.
- * - `gridPermission` — the caller must hold a runtime grid permission; ties
- *   the object to a world region ("movement permission on chunk X opens the
- *   doors in it").
- * - `groupPermission` — the caller must be in a team/group (optionally with a
- *   specific group permission).
- * - `custom` — any hand-written {@link KitInvokePolicy} rule.
- */
-export type LockAuthority = {
-    kind: 'owner';
-} | {
-    kind: 'key';
-} | {
-    kind: 'gridPermission';
-    key: string;
-    gridId?: string;
-} | {
-    /**
-     * The caller must hold the runtime permission on the grid covering the
-     * chunk the OBJECT stands in (`cx`/`cy`/`cz` int properties, seeded via
-     * `ObjectsKit.create({ chunk })`). No hand-pinned grid id — one function
-     * serves every such object in the world. `mode` picks the covering grid
-     * when several overlap: 'first' (enforcement parity, default) |
-     * 'smallest' (innermost plot) | 'largest'. Requires game-api v0.13.12+.
-     */
-    kind: 'chunkPermission';
-    key: string;
-    mode?: 'first' | 'smallest' | 'largest';
-} | {
-    kind: 'groupPermission';
-    groupId: string;
-    permission?: string;
-} | {
-    kind: 'custom';
-    rule: KitInvokePolicy;
-};
-/** Options for {@link lockBlueprint}. */
-export interface LockBlueprintOptions {
-    /**
-     * Container type name for the lockable object (`Door`, `Chest`, `Gate`, …).
-     * Also drives the function names (`open_door` / `close_door`). Defaults to
-     * `'Lockable'`.
-     */
-    objectTypeName?: string;
-    /** Key item type name (only used with a `key` authority). Defaults to `<objectTypeName>Key`. */
-    keyTypeName?: string;
-    /** One or more authority sources; any one grants access. */
-    authority: LockAuthority | LockAuthority[];
-    /**
-     * Extra policy rule AND'ed on top of the OR'd authorities — e.g.
-     * `featureGate('vip')` for members-only doors regardless of keys.
-     */
-    policyExtra?: KitInvokePolicy;
-}
-/** Names derived by {@link lockBlueprint} for a given object type. */
-export interface LockNames {
-    objectType: string;
-    keyType: string;
-    openFn: string;
-    closeFn: string;
-}
-/** Compute the type/function names a lock blueprint (and its runtime helper) uses. */
-export declare function lockNames(objectTypeName?: string, keyTypeName?: string): LockNames;
-/**
- * Blueprint for a **lockable game object** (door, chest, gate, switch) whose
- * `open`/`close` functions are gated by a configurable authority source:
- * ownership, a key item the caller must hold, a runtime grid permission, a
- * team/group permission, or any custom policy rule. Multiple authorities are
- * OR'd, so "the owner, or anyone with the right key" is one blueprint.
- *
- * Runtime counterpart: `client.kit(appId).objects`.
- */
-export declare function lockBlueprint(options: LockBlueprintOptions): KitBlueprint;
-//# sourceMappingURL=locks.d.ts.map

package/dist/kit/blueprints/locks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"locks.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/locks.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACf;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACxD;IACE;;;;;;;OAOG;IACH,IAAI,EAAE,iBAAiB,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CACzC,GACD;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACjE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC;AAE9C,yCAAyC;AACzC,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gGAAgG;IAChG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,SAAS,EAAE,aAAa,GAAG,aAAa,EAAE,CAAC;IAC3C;;;OAGG;IACH,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,sEAAsE;AACtE,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,sFAAsF;AACtF,wBAAgB,SAAS,CACvB,cAAc,SAAa,EAC3B,WAAW,CAAC,EAAE,MAAM,GACnB,SAAS,CAQX;AAwCD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,YAAY,CA6GzE"}

package/dist/kit/blueprints/locks.js

@@ -1,155 +0,0 @@
-import { andPolicies, kitPolicyJson, toSnakeCase, } from './core.js';
-/** Compute the type/function names a lock blueprint (and its runtime helper) uses. */
-export function lockNames(objectTypeName = 'Lockable', keyTypeName) {
-    const snake = toSnakeCase(objectTypeName);
-    return {
-        objectType: objectTypeName,
-        keyType: keyTypeName ?? `${objectTypeName}Key`,
-        openFn: `open_${snake}`,
-        closeFn: `close_${snake}`,
-    };
-}
-function lockAuthorityRule(authority) {
-    switch (authority.kind) {
-        case 'owner':
-            return { type: 'owner_of_self' };
-        case 'key':
-            // Container ownership is not readable from expressions, so the key
-            // mirrors its owner into an `owner_user_id` property; the condition
-            // verifies both the match and the ownership server-side.
-            return {
-                type: 'condition',
-                expression: 'ref($key_id).key_id == self.required_key_id && ref($key_id).owner_user_id == $caller_user_id',
-            };
-        case 'gridPermission':
-            return {
-                type: 'grid_permission',
-                key: authority.key,
-                ...(authority.gridId !== undefined ? { gridId: authority.gridId } : {}),
-            };
-        case 'chunkPermission':
-            // Resolved per-invocation against the grid covering the object's chunk.
-            return {
-                type: 'condition',
-                expression: `has_chunk_permission($caller_user_id, "${authority.key}", self.cx, self.cy, self.cz, "${authority.mode ?? 'first'}")`,
-            };
-        case 'groupPermission':
-            return {
-                type: 'group_permission',
-                groupId: authority.groupId,
-                ...(authority.permission !== undefined
-                    ? { permission: authority.permission }
-                    : {}),
-            };
-        case 'custom':
-            return authority.rule;
-    }
-}
-/**
- * Blueprint for a **lockable game object** (door, chest, gate, switch) whose
- * `open`/`close` functions are gated by a configurable authority source:
- * ownership, a key item the caller must hold, a runtime grid permission, a
- * team/group permission, or any custom policy rule. Multiple authorities are
- * OR'd, so "the owner, or anyone with the right key" is one blueprint.
- *
- * Runtime counterpart: `client.kit(appId).objects`.
- */
-export function lockBlueprint(options) {
-    const authorities = Array.isArray(options.authority)
-        ? options.authority
-        : [options.authority];
-    if (authorities.length === 0) {
-        throw new Error('lockBlueprint requires at least one authority source');
-    }
-    const names = lockNames(options.objectTypeName, options.keyTypeName);
-    const usesKey = authorities.some((a) => a.kind === 'key');
-    const usesChunk = authorities.some((a) => a.kind === 'chunkPermission');
-    const rules = authorities.map(lockAuthorityRule);
-    const policy = rules.length === 1 ? rules[0] : { type: 'or', rules };
-    const policyJson = kitPolicyJson(andPolicies(policy, options.policyExtra));
-    const parameters = usesKey
-        ? [{ name: 'key_id', valueType: 'container_ref', required: true }]
-        : [];
-    const containerTypes = [
-        {
-            typeName: names.objectType,
-            displayName: names.objectType,
-            instantiableBy: 'admin',
-            description: 'A lockable world object operated through gated functions.',
-        },
-    ];
-    const propertyDefinitions = [
-        {
-            containerTypeName: names.objectType,
-            key: 'is_open',
-            valueType: 'bool',
-            defaultValueJson: 'false',
-        },
-    ];
-    if (usesChunk) {
-        // The chunk the object stands in, read by has_chunk_permission().
-        for (const axis of ['cx', 'cy', 'cz']) {
-            propertyDefinitions.push({
-                containerTypeName: names.objectType,
-                key: axis,
-                valueType: 'int',
-                defaultValueJson: '0',
-            });
-        }
-    }
-    if (usesKey) {
-        propertyDefinitions.push({
-            containerTypeName: names.objectType,
-            key: 'required_key_id',
-            valueType: 'string',
-        });
-        containerTypes.push({
-            typeName: names.keyType,
-            displayName: names.keyType,
-            instantiableBy: 'admin',
-            description: 'A key item granting access to matching lockable objects.',
-        });
-        propertyDefinitions.push({ containerTypeName: names.keyType, key: 'key_id', valueType: 'string' }, {
-            containerTypeName: names.keyType,
-            key: 'owner_user_id',
-            valueType: 'int',
-        });
-    }
-    const openMutation = {
-        target: 'self',
-        property: 'is_open',
-        expression: 'true',
-    };
-    const closeMutation = {
-        target: 'self',
-        property: 'is_open',
-        expression: 'false',
-    };
-    return {
-        name: names.objectType,
-        containerTypes,
-        propertyDefinitions,
-        functions: [
-            {
-                name: names.openFn,
-                containerTypeName: names.objectType,
-                returnType: 'bool',
-                parameters,
-                mutations: [openMutation],
-                returnExpression: 'self.is_open',
-                invokePolicyJson: policyJson,
-                description: `Open a ${names.objectType}; the invoke policy decides who may.`,
-            },
-            {
-                name: names.closeFn,
-                containerTypeName: names.objectType,
-                returnType: 'bool',
-                parameters,
-                mutations: [closeMutation],
-                returnExpression: 'self.is_open',
-                invokePolicyJson: policyJson,
-                description: `Close a ${names.objectType}; same authority as opening.`,
-            },
-        ],
-    };
-}

package/dist/kit/blueprints/loot.d.ts

@@ -1,90 +0,0 @@
-import { type KitBlueprint, type KitOwnerIdKind, type KitTrustedAuthority } from './core.js';
-/** One weighted entry of a loot table. */
-export interface LootEntrySpec {
-    itemId: string;
-    /** Relative weight (> 0); probabilities are weights normalized per table. */
-    weight: number;
-    /** Minimum quantity granted. Defaults to 1. */
-    minQty?: number;
-    /** Maximum quantity granted. Defaults to `minQty`. */
-    maxQty?: number;
-}
-/** One loot table, unrolled into a single expression at blueprint-build time. */
-export interface LootTableSpec {
-    /** Stable table identifier; also derives the roll function name. */
-    tableId: string;
-    /** 1–16 weighted entries (the expression parser caps chain length). */
-    entries: LootEntrySpec[];
-}
-/** An event-triggered drop: rolls a pooled LootRoll when a model event fires. */
-export interface LootDropSpec {
-    /** Automation name (unique per app), e.g. `'goblin-drop'`. */
-    name: string;
-    /** The table to roll. */
-    tableId: string;
-    /** The model event that triggers the drop (e.g. a `mob_died` function). */
-    onEvent: 'function_invoked' | 'property_changed' | 'container_created';
-    functionName?: string;
-    containerTypeName?: string;
-    propertyKey?: string;
-    /**
-     * `property_changed` only: which writes roll the drop. Properties mutated
-     * by kit functions (a mob's `hp` reaching 0, say) need `'function'` or
-     * `'any'`; the default `'direct'` only sees client `setProperty` calls.
-     */
-    writeSource?: 'direct' | 'function' | 'any';
-    debounceMs?: number;
-    /** Rolls per event. Defaults to 1. */
-    maxTargets?: number;
-}
-/** Options for {@link lootBlueprint}. */
-export interface LootBlueprintOptions {
-    /** Prefix for the type/function names. Defaults to none. */
-    typePrefix?: string;
-    /** The loot tables; entries are unrolled into expressions at build time. */
-    tables: LootTableSpec[];
-    /**
-     * Who may roll. Defaults to `'server'` (app admins / studio backend);
-     * automations configured via `drops` may always roll (trusted automations
-     * bypass invoke policies, and the roll functions are marked
-     * `autonomousInvocable` when drops reference their table).
-     */
-    rollAuthority?: KitTrustedAuthority;
-    /**
-     * Event-triggered drops: each rolls an UNROLLED pooled `LootRoll` container
-     * of its table when the event fires (automations mutate — they cannot
-     * create containers — so keep a small pool of pre-created rolls per table).
-     */
-    drops?: LootDropSpec[];
-    /** Owner-mirror typing (see the kit convention). Defaults to `'int'`. */
-    ownerIdKind?: KitOwnerIdKind;
-}
-/** Names derived by {@link lootBlueprint} for a given prefix. */
-export interface LootNames {
-    rollType: string;
-    claimFn: string;
-    /** Snake-cased function-name prefix (empty without a `typePrefix`). */
-    fnPrefix: string;
-}
-/** Compute the type/function names a loot blueprint (and its runtime helper) uses. */
-export declare function lootNames(typePrefix?: string): LootNames;
-/** The roll function name for one table. */
-export declare function lootRollFn(tableId: string, typePrefix?: string): string;
-/**
- * Blueprint for **loot tables & drops**: weighted tables are unrolled into
- * pure expressions at blueprint-build time (the expression language is
- * loop-free), rolled server-side into durable `LootRoll` containers, and
- * claimed atomically into an item stack. Covers chest rolls, mob drops, and
- * gacha pulls.
- *
- * Flow: create a `LootRoll` (member) for a table → `roll_<table>` (trusted:
- * server scope by default, or an event automation via `drops`) stores a
- * single `rand()` seed and resolves item + quantity from it in one
- * transaction → the owner claims with `claim_roll`, which marks the roll
- * claimed AND grants the stack in the same invoke (no double-claim, no
- * client-chosen rewards).
- *
- * Runtime counterpart: `client.kit(appId).loot`.
- */
-export declare function lootBlueprint(options: LootBlueprintOptions): KitBlueprint;
-//# sourceMappingURL=loot.d.ts.map

package/dist/kit/blueprints/loot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loot.d.ts","sourceRoot":"","sources":["../../../src/kit/blueprints/loot.ts"],"names":[],"mappings":"AAIA,OAAO,EAQL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAC;AAEnB,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC3B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,OAAO,EAAE,kBAAkB,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,KAAK,CAAC;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,yCAAyC;AACzC,MAAM,WAAW,oBAAoB;IACnC,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB,yEAAyE;IACzE,WAAW,CAAC,EAAE,cAAc,CAAC;CAC9B;AAED,iEAAiE;AACjE,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,sFAAsF;AACtF,wBAAgB,SAAS,CAAC,UAAU,SAAK,GAAG,SAAS,CAOpD;AAED,4CAA4C;AAC5C,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,SAAK,GAAG,MAAM,CAGnE;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,YAAY,CAwLzE"}