@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.333

package/packages/typescript/src/actions.js

@@ -0,0 +1,531 @@
+import { allActionDocs } from "./generated/action-docs.js";
+import { buildDeterministicSeed, createDeterministicRandom, deterministicShuffle, getDeterministicNames, } from "./utils/deterministic";
+import { encodeToonValue, parseToonActionParams, tryParseToonValue, } from "./utils/toon";
+import { parseJSONObjectFromText } from "./utils.js";
+const actionDocByName = allActionDocs.reduce((acc, doc) => {
+    acc[doc.name] = doc;
+    return acc;
+}, {});
+export const composeActionExamples = (actionsData, count, seed = "actions") => {
+    if (!actionsData.length || count <= 0) {
+        return "";
+    }
+    const actionsWithExamples = actionsData.filter((action) => action.examples &&
+        Array.isArray(action.examples) &&
+        action.examples.length > 0);
+    if (!actionsWithExamples.length) {
+        return "";
+    }
+    const examplesCopy = actionsWithExamples.map((action) => [...(action.examples || [])]);
+    const selectedExamples = [];
+    const random = createDeterministicRandom(buildDeterministicSeed(seed, "examples"));
+    const availableActionIndices = examplesCopy
+        .map((examples, index) => (examples.length > 0 ? index : -1))
+        .filter((index) => index !== -1);
+    while (selectedExamples.length < count && availableActionIndices.length > 0) {
+        const randomIndex = Math.floor(random() * availableActionIndices.length);
+        const actionIndex = availableActionIndices[randomIndex];
+        const examples = examplesCopy[actionIndex];
+        const exampleIndex = Math.floor(random() * examples.length);
+        selectedExamples.push(examples.splice(exampleIndex, 1)[0]);
+        if (examples.length === 0) {
+            availableActionIndices.splice(randomIndex, 1);
+        }
+    }
+    return formatSelectedExamples(selectedExamples, buildDeterministicSeed(seed, "names"));
+};
+function formatActionCallExample(example) {
+    const paramsByAction = example.params ?? {};
+    const assistantPayload = {
+        actions: [...example.actions],
+    };
+    if (Object.keys(paramsByAction).length > 0) {
+        assistantPayload.params = paramsByAction;
+    }
+    return `User: ${example.user}\nAssistant:\n${encodeToonValue(assistantPayload)}`;
+}
+/**
+ * Render canonical action-call examples (including <params> blocks).
+ *
+ * Deterministic ordering is important to keep tests stable and avoid prompt churn.
+ */
+export function composeActionCallExamples(actionsData, maxExamples) {
+    if (!actionsData.length || maxExamples <= 0)
+        return "";
+    const blocks = [];
+    const sorted = [...actionsData].sort((a, b) => a.name.localeCompare(b.name));
+    for (const action of sorted) {
+        const doc = actionDocByName[action.name];
+        if (!doc?.exampleCalls || doc.exampleCalls.length === 0)
+            continue;
+        for (const ex of doc.exampleCalls) {
+            blocks.push(formatActionCallExample(ex));
+            if (blocks.length >= maxExamples)
+                return blocks.join("\n\n");
+        }
+    }
+    return blocks.join("\n\n");
+}
+const formatSelectedExamples = (examples, seed = "actions") => {
+    const MAX_NAME_PLACEHOLDERS = 5;
+    return examples
+        .map((example, index) => {
+        const randomNames = getDeterministicNames(MAX_NAME_PLACEHOLDERS, buildDeterministicSeed(seed, index));
+        const conversation = example
+            .map((message) => {
+            let messageText = `${message.name}: ${message.content.text}`;
+            for (let i = 0; i < randomNames.length; i++) {
+                messageText = messageText.replaceAll(`{{name${i + 1}}}`, randomNames[i]);
+            }
+            return messageText;
+        })
+            .join("\n");
+        return `\n${conversation}`;
+    })
+        .join("\n");
+};
+function getExampleActionHints(example) {
+    const hints = new Set();
+    for (const message of example) {
+        const content = message.content;
+        if (typeof content.action === "string" && content.action.trim()) {
+            hints.add(content.action.trim());
+        }
+        if (Array.isArray(content.actions)) {
+            for (const action of content.actions) {
+                if (typeof action === "string" && action.trim()) {
+                    hints.add(action.trim());
+                }
+            }
+        }
+    }
+    return [...hints];
+}
+function formatActionExampleSummary(action) {
+    const examples = action.examples ?? [];
+    if (!Array.isArray(examples) || examples.length === 0) {
+        return null;
+    }
+    for (const example of examples) {
+        if (!Array.isArray(example) || example.length === 0) {
+            continue;
+        }
+        const userMessage = example[0]?.content?.text?.trim();
+        const actionHints = getExampleActionHints(example);
+        if (!userMessage) {
+            continue;
+        }
+        if (actionHints.length === 0) {
+            return `User: ${JSON.stringify(userMessage)} -> actions: ${action.name}`;
+        }
+        return `User: ${JSON.stringify(userMessage)} -> actions: ${actionHints.join(", ")}`;
+    }
+    return null;
+}
+function shuffleActions(items, seed = "actions") {
+    return deterministicShuffle(items, seed);
+}
+function formatActionSimiles(action) {
+    const similes = [
+        ...new Set((action.similes ?? []).map((simile) => simile.trim())),
+    ].filter((simile) => simile.length > 0);
+    if (similes.length === 0) {
+        return null;
+    }
+    return `  aliases[${similes.length}]: ${similes.join(", ")}`;
+}
+function formatActionTags(action) {
+    const tags = [
+        ...new Set((action.tags ?? []).map((tag) => tag.trim())),
+    ].filter((tag) => tag.length > 0 && tag !== "always-include");
+    if (tags.length === 0) {
+        return null;
+    }
+    return `  tags[${tags.length}]: ${tags.join(", ")}`;
+}
+export function formatActionNames(actions, seed = "actions") {
+    if (!actions?.length)
+        return "";
+    return shuffleActions(actions, buildDeterministicSeed(seed, "names"))
+        .map((action) => action.name)
+        .join(", ");
+}
+export function formatActions(actions, seed = "actions") {
+    if (!actions?.length)
+        return "";
+    const actionLines = shuffleActions(actions, buildDeterministicSeed(seed, "descriptions"))
+        .map((action) => {
+        const lines = [
+            `- ${action.name}: ${action.description || "No description available"}`,
+        ];
+        const exampleSummary = formatActionExampleSummary(action);
+        const similes = formatActionSimiles(action);
+        const tags = formatActionTags(action);
+        if (similes) {
+            lines.push(similes);
+        }
+        if (tags) {
+            lines.push(tags);
+        }
+        if (action.parameters && action.parameters.length > 0) {
+            lines.push(`  params[${action.parameters.length}]: ${formatActionParameters(action.parameters)}`);
+        }
+        if (exampleSummary) {
+            lines.push(`  example: ${exampleSummary}`);
+        }
+        return lines.join("\n");
+    })
+        .join("\n");
+    return `actions[${actions.length}]:\n${actionLines}`;
+}
+export function formatActionParameters(parameters) {
+    if (!parameters?.length)
+        return "";
+    return parameters
+        .map((param) => {
+        const typeStr = formatParameterType(param.schema);
+        const modifiers = [];
+        if (param.schema.enum?.length) {
+            modifiers.push(`values=${param.schema.enum.join("|")}`);
+        }
+        if (param.schema.default !== undefined) {
+            modifiers.push(`default=${JSON.stringify(param.schema.default)}`);
+        }
+        if (param.examples && param.examples.length > 0) {
+            modifiers.push(`examples=${param.examples.map((v) => JSON.stringify(v)).join("|")}`);
+        }
+        const suffix = modifiers.length > 0 ? ` [${modifiers.join("; ")}]` : "";
+        return `${param.name}${param.required ? "" : "?"}:${typeStr}${suffix} - ${param.description}`;
+    })
+        .join("; ");
+}
+function formatParameterType(schema) {
+    switch (schema.type) {
+        case "string":
+            return "string";
+        case "number":
+            return schema.minimum !== undefined || schema.maximum !== undefined
+                ? `number [${schema.minimum ?? "∞"}-${schema.maximum ?? "∞"}]`
+                : "number";
+        case "boolean":
+            return "boolean";
+        case "array":
+            return schema.items
+                ? `array of ${formatParameterType(schema.items)}`
+                : "array";
+        case "object":
+            return "object";
+        default:
+            return schema.type;
+    }
+}
+/**
+ * Parse action parameters from either the new nested format or the legacy flat format.
+ *
+ * New format (preferred):
+ *   <actions>
+ *     <action><name>ACTION1</name><params><p1>v1</p1></params></action>
+ *   </actions>
+ *
+ * Legacy format (backward-compat – previously stored in content.params):
+ *   <ACTION1><p1>v1</p1></ACTION1>
+ */
+export function parseActionParams(paramsInput) {
+    const toonParams = parseToonActionParams(paramsInput);
+    if (toonParams.size > 0) {
+        return toonParams;
+    }
+    const result = new Map();
+    if (!paramsInput || typeof paramsInput !== "string") {
+        return result;
+    }
+    const paramsXml = paramsInput;
+    // ---- New nested format: look for <action> children ----
+    const actionChildren = extractXmlChildren(paramsXml);
+    const actionElements = actionChildren.filter((c) => c.key === "action");
+    if (actionElements.length > 0) {
+        for (const { value: actionXml } of actionElements) {
+            const children = extractXmlChildren(actionXml);
+            const nameEntry = children.find((c) => c.key === "name");
+            const paramsEntry = children.find((c) => c.key === "params");
+            if (!nameEntry)
+                continue;
+            const actionName = nameEntry.value.trim().toUpperCase();
+            if (!actionName)
+                continue;
+            if (paramsEntry) {
+                const paramPairs = extractXmlChildren(paramsEntry.value);
+                const actionParams = {};
+                for (const { key: paramName, value: paramValue } of paramPairs) {
+                    actionParams[paramName] = parseParamValue(paramValue);
+                }
+                if (Object.keys(actionParams).length > 0) {
+                    result.set(actionName, actionParams);
+                }
+            }
+        }
+        return result;
+    }
+    // ---- Legacy flat format: <ACTION_NAME><param>value</param></ACTION_NAME> ----
+    for (const { key: actionName, value: actionParamsXml } of actionChildren) {
+        const params = extractXmlChildren(actionParamsXml);
+        const actionParams = {};
+        for (const { key: paramName, value: paramValue } of params) {
+            actionParams[paramName] = parseParamValue(paramValue);
+        }
+        if (Object.keys(actionParams).length === 0) {
+            const structuredParams = parseJSONObjectFromText(actionParamsXml) ??
+                tryParseToonValue(actionParamsXml);
+            if (structuredParams &&
+                typeof structuredParams === "object" &&
+                !Array.isArray(structuredParams)) {
+                for (const [paramName, paramValue] of Object.entries(structuredParams)) {
+                    actionParams[paramName] = toActionParameterValue(paramValue);
+                }
+            }
+        }
+        if (Object.keys(actionParams).length > 0) {
+            result.set(actionName.toUpperCase(), actionParams);
+        }
+    }
+    return result;
+}
+function extractXmlChildren(xml) {
+    const pairs = [];
+    const length = xml.length;
+    let i = 0;
+    while (i < length) {
+        const openIdx = xml.indexOf("<", i);
+        if (openIdx === -1)
+            break;
+        if (xml.startsWith("</", openIdx) ||
+            xml.startsWith("<!--", openIdx) ||
+            xml.startsWith("<?", openIdx)) {
+            i = openIdx + 1;
+            continue;
+        }
+        let j = openIdx + 1;
+        let tag = "";
+        while (j < length) {
+            const ch = xml[j];
+            if (/^[A-Za-z0-9_-]$/.test(ch)) {
+                tag += ch;
+                j++;
+                continue;
+            }
+            break;
+        }
+        if (!tag) {
+            i = openIdx + 1;
+            continue;
+        }
+        const startTagEnd = xml.indexOf(">", j);
+        if (startTagEnd === -1)
+            break;
+        const startTagText = xml.slice(openIdx, startTagEnd + 1);
+        if (/\/\s*>$/.test(startTagText)) {
+            i = startTagEnd + 1;
+            continue;
+        }
+        const closeSeq = `</${tag}>`;
+        let depth = 1;
+        let searchStart = startTagEnd + 1;
+        while (depth > 0 && searchStart < length) {
+            const nextOpen = xml.indexOf(`<${tag}`, searchStart);
+            const nextClose = xml.indexOf(closeSeq, searchStart);
+            if (nextClose === -1)
+                break;
+            if (nextOpen !== -1 && nextOpen < nextClose) {
+                const nestedStartEnd = xml.indexOf(">", nextOpen + 1);
+                if (nestedStartEnd === -1)
+                    break;
+                const nestedStartText = xml.slice(nextOpen, nestedStartEnd + 1);
+                if (!/\/\s*>$/.test(nestedStartText)) {
+                    depth++;
+                }
+                searchStart = nestedStartEnd + 1;
+            }
+            else {
+                depth--;
+                searchStart = nextClose + closeSeq.length;
+            }
+        }
+        if (depth !== 0) {
+            i = startTagEnd + 1;
+            continue;
+        }
+        const closeIdx = searchStart - closeSeq.length;
+        const innerRaw = xml.slice(startTagEnd + 1, closeIdx).trim();
+        pairs.push({ key: tag, value: innerRaw });
+        i = searchStart;
+    }
+    return pairs;
+}
+function toActionParameterValue(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => toActionParameterValue(entry));
+    }
+    if (value && typeof value === "object") {
+        const normalized = {};
+        for (const [key, entry] of Object.entries(value)) {
+            normalized[key] = toActionParameterValue(entry);
+        }
+        return normalized;
+    }
+    return value === undefined ? null : String(value);
+}
+function parseParamValue(value) {
+    if (!value || value === "")
+        return null;
+    const lower = value.toLowerCase();
+    if (lower === "true")
+        return true;
+    if (lower === "false")
+        return false;
+    if (lower === "null")
+        return null;
+    const num = Number(value);
+    if (!Number.isNaN(num) && value.trim() !== "") {
+        return num;
+    }
+    return value;
+}
+export function validateActionParams(action, extractedParams) {
+    const errors = [];
+    const params = {};
+    if (!action.parameters || action.parameters.length === 0) {
+        return { valid: true, params: undefined, errors: [] };
+    }
+    for (const paramDef of action.parameters) {
+        const extractedValue = coerceActionParamValue(paramDef, extractedParams ? extractedParams[paramDef.name] : undefined);
+        if (extractedValue === undefined || extractedValue === null) {
+            if (paramDef.required) {
+                errors.push(`Required parameter '${paramDef.name}' was not provided for action ${action.name}`);
+            }
+            else if (paramDef.schema.default !== undefined) {
+                params[paramDef.name] = paramDef.schema.default;
+            }
+        }
+        else {
+            const typeError = validateParamType(paramDef, extractedValue);
+            if (typeError) {
+                if (paramDef.required) {
+                    errors.push(typeError);
+                }
+                else if (paramDef.schema.default !== undefined) {
+                    params[paramDef.name] = paramDef.schema.default;
+                }
+            }
+            else {
+                params[paramDef.name] = extractedValue;
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        params: Object.keys(params).length > 0 ? params : undefined,
+        errors,
+    };
+}
+function coerceActionParamValue(paramDef, value) {
+    if (paramDef.schema.type === "string" &&
+        (typeof value === "number" || typeof value === "bigint")) {
+        return String(value);
+    }
+    if (paramDef.schema.type !== "array" || Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed.map((entry) => toActionParameterValue(entry));
+            }
+        }
+        catch {
+            // Fall through to the permissive toon/string coercion paths below.
+        }
+    }
+    const xmlChildren = extractXmlChildren(trimmed);
+    if (xmlChildren.length > 0) {
+        return xmlChildren.map(({ value: childValue }) => toActionParameterValue(childValue));
+    }
+    const toonValue = tryParseToonValue(trimmed);
+    if (Array.isArray(toonValue)) {
+        return toonValue.map((entry) => toActionParameterValue(entry));
+    }
+    if (paramDef.schema.items?.type !== "string") {
+        return value;
+    }
+    const splitValues = trimmed
+        .split(/\s*\|\|\s*|,|\n/)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    if (splitValues.length === 0) {
+        return [];
+    }
+    return splitValues;
+}
+function validateParamType(paramDef, value) {
+    const { schema, name } = paramDef;
+    switch (schema.type) {
+        case "string": {
+            if (typeof value !== "string") {
+                return `Parameter '${name}' expected string, got ${typeof value}`;
+            }
+            const enumValues = schema.enumValues ?? schema.enum;
+            if (enumValues && !enumValues.includes(value)) {
+                return `Parameter '${name}' value '${value}' not in allowed values: ${enumValues.join(", ")}`;
+            }
+            if (schema.pattern) {
+                const regex = new RegExp(schema.pattern);
+                if (!regex.test(value)) {
+                    return `Parameter '${name}' value '${value}' does not match pattern: ${schema.pattern}`;
+                }
+            }
+            break;
+        }
+        case "number":
+            if (typeof value !== "number") {
+                return `Parameter '${name}' expected number, got ${typeof value}`;
+            }
+            if (schema.minimum !== undefined && value < schema.minimum) {
+                return `Parameter '${name}' value ${value} is below minimum ${schema.minimum}`;
+            }
+            if (schema.maximum !== undefined && value > schema.maximum) {
+                return `Parameter '${name}' value ${value} is above maximum ${schema.maximum}`;
+            }
+            break;
+        case "boolean":
+            if (typeof value !== "boolean") {
+                return `Parameter '${name}' expected boolean, got ${typeof value}`;
+            }
+            break;
+        case "array":
+            if (!Array.isArray(value)) {
+                return `Parameter '${name}' expected array, got ${typeof value}`;
+            }
+            break;
+        case "object":
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                return `Parameter '${name}' expected object, got ${typeof value}`;
+            }
+            break;
+    }
+    return undefined;
+}

package/packages/typescript/src/character-utils.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Character Utilities
+ *
+ * Utilities for managing character secrets, plugins, and model provider detection.
+ * These are immutable operations that return new character objects.
+ *
+ * Note: Secrets are stored in character.settings.secrets for compatibility
+ * with the Eliza runtime and existing character files.
+ *
+ * @module character-utils
+ */
+import { CHANNEL_SECRETS, resolveSecretKeyAlias, SECRET_KEY_ALIASES } from "./constants/secrets";
+import type { Character } from "./types";
+/**
+ * Mapping of model provider names to their corresponding API key environment variables.
+ * Re-exported from constants/secrets for backward compatibility.
+ * @see {@link ./constants/secrets} for the comprehensive list
+ */
+export declare const MODEL_PROVIDER_SECRETS: Record<string, string>;
+/**
+ * Re-export CHANNEL_SECRETS and alias utilities from constants
+ */
+export { CHANNEL_SECRETS, resolveSecretKeyAlias, SECRET_KEY_ALIASES };
+/**
+ * Common secret keys that are typically imported from environment variables.
+ * These include API keys for various services the agent may use.
+ * Based on CANONICAL_SECRET_KEYS but filtered to commonly used keys.
+ */
+export declare const COMMON_SECRET_KEYS: string[];
+/**
+ * Get a secret value from character.settings.secrets, falling back to process.env.
+ *
+ * @param character - The character to get the secret from
+ * @param key - The secret key to look up
+ * @returns The secret value, or null if not found in either location
+ */
+export declare function getCharacterSecret(character: Character, key: string): string | null;
+/**
+ * Set a secret in character.settings.secrets. This is an immutable operation
+ * that returns a new character object.
+ *
+ * @param character - The character to modify
+ * @param key - The secret key to set
+ * @param value - The secret value
+ * @returns A new character with the secret set
+ */
+export declare function setCharacterSecret(character: Character, key: string, value: string): Character;
+/**
+ * Check if a secret exists in character.settings.secrets or process.env.
+ *
+ * @param character - The character to check
+ * @param key - The secret key to look for
+ * @returns true if the secret exists and has a non-empty value
+ */
+export declare function hasCharacterSecret(character: Character, key: string): boolean;
+/**
+ * Delete a secret from character.settings.secrets. This is an immutable operation
+ * that returns a new character object.
+ *
+ * @param character - The character to modify
+ * @param key - The secret key to delete
+ * @returns A new character with the secret removed
+ */
+export declare function deleteCharacterSecret(character: Character, key: string): Character;
+/**
+ * List all secret keys (not values) from character.settings.secrets.
+ *
+ * @param character - The character to list secrets from
+ * @returns Array of secret key names
+ */
+export declare function listCharacterSecretKeys(character: Character): string[];
+/**
+ * Sync character secrets to process.env. Existing environment variables
+ * are not overwritten.
+ *
+ * @param character - The character whose secrets to sync
+ * @returns The number of secrets that were synced
+ */
+export declare function syncCharacterSecretsToEnv(character: Character): number;
+/**
+ * Import secrets from process.env into character.settings.secrets.
+ * Existing character secrets take priority and are not overwritten.
+ *
+ * @param character - The character to import secrets into
+ * @param keys - Array of environment variable keys to import
+ * @returns A new character with the imported secrets
+ */
+export declare function importSecretsFromEnv(character: Character, keys: string[]): Character;
+/**
+ * Merge secrets into character.settings.secrets. Existing character secrets
+ * take priority and are not overwritten.
+ *
+ * @param character - The character to merge secrets into
+ * @param secrets - The secrets to merge
+ * @returns A new character with the merged secrets
+ */
+export declare function mergeCharacterSecrets(character: Character, secrets: Record<string, string>): Character;
+/**
+ * Add a plugin to character.plugins. This is an immutable operation.
+ * If the plugin is already present, the original character is returned.
+ *
+ * @param character - The character to modify
+ * @param pluginName - The plugin name to add (e.g., "@elizaos/plugin-discord")
+ * @returns A new character with the plugin added, or the original if already present
+ */
+export declare function addCharacterPlugin(character: Character, pluginName: string): Character;
+/**
+ * Remove a plugin from character.plugins. This is an immutable operation.
+ *
+ * @param character - The character to modify
+ * @param pluginName - The plugin name to remove
+ * @returns A new character with the plugin removed
+ */
+export declare function removeCharacterPlugin(character: Character, pluginName: string): Character;
+/**
+ * Check if a plugin is enabled on the character.
+ *
+ * @param character - The character to check
+ * @param pluginName - The plugin name to look for
+ * @returns true if the plugin is in character.plugins
+ */
+export declare function hasCharacterPlugin(character: Character, pluginName: string): boolean;
+/**
+ * Detect which AI model provider is configured based on available API keys.
+ * Checks character.secrets first, then falls back to process.env.
+ *
+ * @param character - The character to check
+ * @returns The provider name (e.g., "anthropic", "openai") or null if none found
+ */
+export declare function getModelProvider(character: Character): string | null;
+/**
+ * Get all configured model providers for a character.
+ *
+ * @param character - The character to check
+ * @returns Array of provider names that have API keys configured
+ */
+export declare function getConfiguredModelProviders(character: Character): string[];
+//# sourceMappingURL=character-utils.d.ts.map

package/packages/typescript/src/character-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-utils.d.ts","sourceRoot":"","sources":["../../../../../typescript/src/character-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAEN,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAMzC;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,wBAA0B,CAAC;AAE9D;;GAEG;AACH,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,UAqB9B,CAAC;AAMF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,GACT,MAAM,GAAG,IAAI,CAYf;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACX,SAAS,CAaX;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE7E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,GACT,SAAS,CAWX;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,EAAE,CAKtE;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAYtE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,MAAM,EAAE,GACZ,SAAS,CAWX;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,SAAS,CAmBX;AAMD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,MAAM,GAChB,SAAS,CAUX;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACpC,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,MAAM,GAChB,SAAS,CAOX;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,MAAM,GAChB,OAAO,CAET;AAMD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAOpE;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,EAAE,CAQ1E"}