dynim-core 1.0.0

package/dist/builder/style-applier.js

@@ -0,0 +1,311 @@
+/**
+ * Style Applier - Parses code edits and applies styling changes directly to DOM
+ *
+ * Extracts styling-related changes from React/JSX code diffs:
+ * - className prop changes
+ * - style prop changes
+ * - Tailwind class additions/removals
+ *
+ * Then applies them to the corresponding DOM elements without requiring a bundle reload.
+ */
+import { getFiberFromDOM } from './fiber-capture';
+/**
+ * Extract component name from file path
+ * e.g., "components/Button.tsx" -> "Button"
+ */
+function extractComponentName(filePath) {
+    const match = filePath.match(/([A-Z][a-zA-Z0-9]*)\.(tsx?|jsx?)$/);
+    return match ? match[1] : null;
+}
+/**
+ * Parse className from JSX
+ * Handles: className="foo", className={'foo'}, className={`foo`}
+ */
+function parseClassName(code) {
+    // Match className="..." or className={'...'} or className={`...`}
+    const patterns = [
+        /className\s*=\s*"([^"]*)"/,
+        /className\s*=\s*'([^']*)'/,
+        /className\s*=\s*\{['"`]([^'"`]*?)['"`]\}/,
+        /className\s*=\s*\{`([^`]*?)`\}/,
+    ];
+    for (const pattern of patterns) {
+        const match = code.match(pattern);
+        if (match) {
+            return match[1];
+        }
+    }
+    return null;
+}
+/**
+ * Parse inline style from JSX
+ * Handles: style={{ color: 'red' }}
+ */
+function parseStyleProp(code) {
+    // Match style={{ ... }}
+    const match = code.match(/style\s*=\s*\{\{([^}]*)\}\}/);
+    if (!match)
+        return null;
+    const styleStr = match[1];
+    const styles = {};
+    // Parse key: value pairs (handles both 'value' and "value")
+    const propPattern = /(\w+)\s*:\s*['"]([^'"]+)['"]/g;
+    let propMatch;
+    while ((propMatch = propPattern.exec(styleStr)) !== null) {
+        // Convert camelCase to kebab-case for CSS
+        const key = propMatch[1].replace(/([A-Z])/g, '-$1').toLowerCase();
+        styles[key] = propMatch[2];
+    }
+    return Object.keys(styles).length > 0 ? styles : null;
+}
+/**
+ * Find the differences between two class strings
+ */
+function diffClasses(oldClasses, newClasses) {
+    const oldSet = new Set(oldClasses.split(/\s+/).filter(Boolean));
+    const newSet = new Set(newClasses.split(/\s+/).filter(Boolean));
+    const add = [];
+    const remove = [];
+    for (const cls of newSet) {
+        if (!oldSet.has(cls))
+            add.push(cls);
+    }
+    for (const cls of oldSet) {
+        if (!newSet.has(cls))
+            remove.push(cls);
+    }
+    return { add, remove };
+}
+/**
+ * Find style property differences
+ */
+function diffStyles(oldStyles, newStyles) {
+    const changes = [];
+    const allKeys = new Set([
+        ...Object.keys(oldStyles || {}),
+        ...Object.keys(newStyles || {}),
+    ]);
+    for (const key of allKeys) {
+        const oldVal = oldStyles?.[key];
+        const newVal = newStyles?.[key];
+        if (oldVal !== newVal) {
+            changes.push({ property: key, oldValue: oldVal, newValue: newVal });
+        }
+    }
+    return changes;
+}
+/**
+ * Try to find elements by component name using React fiber
+ */
+function findElementsByFiber(componentName, root = document.body) {
+    const elements = [];
+    // Walk the DOM looking for elements rendered by this component
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+    let node = walker.nextNode();
+    while (node) {
+        const fiber = getFiberFromDOM(node);
+        if (fiber) {
+            // Check if this fiber's component matches
+            const type = fiber.type;
+            let name = null;
+            if (typeof type === 'function') {
+                name = type.displayName ||
+                    type.name || null;
+            }
+            if (name === componentName) {
+                elements.push(node);
+            }
+        }
+        node = walker.nextNode();
+    }
+    return elements;
+}
+/**
+ * Generate a selector to find elements
+ */
+function generateSelector(componentName) {
+    // Try common patterns:
+    // - data-component attribute
+    // - data-testid attribute
+    // - class name based on component
+    return [
+        `[data-component="${componentName}"]`,
+        `[data-testid="${componentName}"]`,
+        `[data-testid="${componentName.toLowerCase()}"]`,
+        `.${componentName}`,
+        `.${componentName.toLowerCase()}`,
+    ].join(', ');
+}
+/**
+ * Create a style applier instance
+ */
+export function createStyleApplier(config = {}) {
+    const { queryElements = (sel) => document.querySelectorAll(sel), mapComponentToElements, onApply, onError, } = config;
+    /**
+     * Parse a code edit and extract style changes
+     */
+    function parseEdit(edit) {
+        const changes = [];
+        if (!edit.old_content && !edit.new_content) {
+            return changes;
+        }
+        const componentName = extractComponentName(edit.file_path);
+        // Parse classNames
+        const oldClassName = edit.old_content ? parseClassName(edit.old_content) : null;
+        const newClassName = edit.new_content ? parseClassName(edit.new_content) : null;
+        if (oldClassName !== newClassName && (oldClassName || newClassName)) {
+            // Determine if this is a full className change or Tailwind add/remove
+            if (oldClassName && newClassName) {
+                const { add, remove } = diffClasses(oldClassName, newClassName);
+                if (add.length > 0 || remove.length > 0) {
+                    // Tailwind-style class manipulation
+                    changes.push({
+                        type: 'tailwind',
+                        filePath: edit.file_path,
+                        componentName: componentName || undefined,
+                        oldClassName,
+                        newClassName,
+                        addClasses: add,
+                        removeClasses: remove,
+                    });
+                }
+            }
+            else {
+                // Full className replacement
+                changes.push({
+                    type: 'className',
+                    filePath: edit.file_path,
+                    componentName: componentName || undefined,
+                    oldClassName: oldClassName || undefined,
+                    newClassName: newClassName || undefined,
+                });
+            }
+        }
+        // Parse style props
+        const oldStyles = edit.old_content ? parseStyleProp(edit.old_content) : null;
+        const newStyles = edit.new_content ? parseStyleProp(edit.new_content) : null;
+        const styleDiffs = diffStyles(oldStyles, newStyles);
+        for (const diff of styleDiffs) {
+            changes.push({
+                type: 'style',
+                filePath: edit.file_path,
+                componentName: componentName || undefined,
+                styleProperty: diff.property,
+                oldValue: diff.oldValue,
+                newValue: diff.newValue,
+            });
+        }
+        return changes;
+    }
+    /**
+     * Find DOM elements for a component
+     */
+    function findElements(componentName, filePath) {
+        // Try custom mapping first
+        if (mapComponentToElements) {
+            const elements = mapComponentToElements(componentName, filePath);
+            if (elements.length > 0)
+                return elements;
+        }
+        // Try fiber-based lookup
+        try {
+            const fiberElements = findElementsByFiber(componentName);
+            if (fiberElements.length > 0)
+                return fiberElements;
+        }
+        catch (e) {
+            // Fiber lookup failed, continue to selector fallback
+        }
+        // Fall back to selector-based lookup
+        const selector = generateSelector(componentName);
+        return Array.from(queryElements(selector));
+    }
+    /**
+     * Apply a style change to the DOM
+     */
+    function applyChange(change) {
+        const elements = [];
+        try {
+            // Find target elements
+            if (change.componentName) {
+                elements.push(...findElements(change.componentName, change.filePath));
+            }
+            else if (change.selector) {
+                elements.push(...Array.from(queryElements(change.selector)));
+            }
+            if (elements.length === 0) {
+                console.warn(`[StyleApplier] No elements found for:`, change);
+                return elements;
+            }
+            // Apply the change
+            for (const el of elements) {
+                const htmlEl = el;
+                switch (change.type) {
+                    case 'className':
+                        if (change.newClassName !== undefined) {
+                            htmlEl.className = change.newClassName;
+                        }
+                        break;
+                    case 'tailwind':
+                        if (change.removeClasses) {
+                            change.removeClasses.forEach(cls => {
+                                if (cls)
+                                    htmlEl.classList.remove(cls);
+                            });
+                        }
+                        if (change.addClasses) {
+                            change.addClasses.forEach(cls => {
+                                if (cls)
+                                    htmlEl.classList.add(cls);
+                            });
+                        }
+                        break;
+                    case 'style':
+                        if (change.styleProperty) {
+                            if (change.newValue !== undefined) {
+                                htmlEl.style.setProperty(change.styleProperty, change.newValue);
+                            }
+                            else {
+                                htmlEl.style.removeProperty(change.styleProperty);
+                            }
+                        }
+                        break;
+                }
+            }
+            onApply?.(change, elements);
+        }
+        catch (error) {
+            console.error('[StyleApplier] Failed to apply change:', error);
+            onError?.(change, error);
+        }
+        return elements;
+    }
+    /**
+     * Parse and apply all style changes from an edit
+     */
+    function processEdit(edit) {
+        const changes = parseEdit(edit);
+        let applied = 0;
+        for (const change of changes) {
+            const elements = applyChange(change);
+            if (elements.length > 0) {
+                applied++;
+            }
+        }
+        return { changes, applied };
+    }
+    return {
+        parseEdit,
+        applyChange,
+        processEdit,
+        findElements,
+    };
+}
+/**
+ * Utility: Check if an edit likely contains style changes
+ * Quick check before doing full parsing
+ */
+export function hasStyleChanges(edit) {
+    const content = (edit.old_content || '') + (edit.new_content || '');
+    return /className|style\s*=|class\s*=/.test(content);
+}

package/dist/builder/tree-state.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Component tree state management
+ * Stores the serialized DOM tree for navigation and classification
+ */
+import { type Classification } from './classifier/index';
+export interface TreeNode {
+    id: string;
+    tagName: string;
+    className: string;
+    selector: string;
+    classification: Classification;
+    parentId: string | null;
+    childIds: string[];
+    depth: number;
+    domPath: number[];
+    stableId: string | null;
+    boundingRect: SerializedRect | null;
+    computedStyles: Record<string, string> | null;
+    isExpanded: boolean;
+    isVisible: boolean;
+    attributes: Record<string, string> | null;
+    textContent: string | null;
+    childCount: number;
+}
+export interface SerializedRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface SerializedDOMNode {
+    domPath: number[];
+    tagName: string;
+    id: string | null;
+    className: string;
+    rect: SerializedRect;
+    computedStyles: Record<string, string>;
+    computedDisplay: string;
+    hasChildren: boolean;
+    textContent: string | null;
+    attributes: Record<string, string>;
+    childCount: number;
+    children: SerializedDOMNode[];
+    depth: number;
+}
+export interface TreeStateData {
+    nodesById: Record<string, TreeNode>;
+    rootIds: string[];
+    nodesByDomPath: Record<string, string>;
+    nodesByStableId: Record<string, string>;
+    expandedIds: Set<string>;
+}
+export type TreeStateListener = (state: TreeStateData) => void;
+export interface TreeState {
+    getState: () => TreeStateData;
+    setState: (updates: Partial<TreeStateData>) => void;
+    subscribe: (listener: TreeStateListener) => () => void;
+    setTree: (root: SerializedDOMNode) => void;
+    expandToNode: (id: string) => void;
+    getNodeByDomPath: (path: number[]) => TreeNode | null;
+    getNodeByStableId: (stableId: string) => TreeNode | null;
+    getNodeById: (id: string) => TreeNode | null;
+    toggleExpanded: (id: string) => void;
+    clear: () => void;
+}
+export declare function createTreeState(initialState?: Partial<TreeStateData>): TreeState;
+//# sourceMappingURL=tree-state.d.ts.map

package/dist/builder/tree-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-state.d.ts","sourceRoot":"","sources":["../../src/builder/tree-state.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE3E,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,YAAY,EAAE,cAAc,GAAG,IAAI,CAAC;IACpC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAC9C,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAC1C,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACpC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAE/D,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,aAAa,CAAC;IAC9B,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC;IACpD,SAAS,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,MAAM,IAAI,CAAC;IACvD,OAAO,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC3C,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,QAAQ,GAAG,IAAI,CAAC;IACtD,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,QAAQ,GAAG,IAAI,CAAC;IACzD,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,QAAQ,GAAG,IAAI,CAAC;IAC7C,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,wBAAgB,eAAe,CAAC,YAAY,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,SAAS,CA+LpF"}

package/dist/builder/tree-state.js

@@ -0,0 +1,168 @@
+/**
+ * Component tree state management
+ * Stores the serialized DOM tree for navigation and classification
+ */
+import { createClassifier } from './classifier/index';
+export function createTreeState(initialState = {}) {
+    let state = {
+        nodesById: {},
+        rootIds: [],
+        nodesByDomPath: {},
+        nodesByStableId: {},
+        expandedIds: new Set(),
+        ...initialState
+    };
+    const listeners = new Set();
+    const classifier = createClassifier();
+    function getState() {
+        return {
+            ...state,
+            expandedIds: new Set(state.expandedIds)
+        };
+    }
+    function setState(updates) {
+        state = { ...state, ...updates };
+        listeners.forEach(listener => listener(state));
+    }
+    function subscribe(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+    }
+    function generateId() {
+        return Math.random().toString(36).substr(2, 10);
+    }
+    function generateSelector(node) {
+        const tag = node.tagName.toLowerCase();
+        const id = node.id ? `#${node.id}` : '';
+        const classes = (node.className || '')
+            .split(/\s+/)
+            .filter(c => {
+            if (!c)
+                return false;
+            if (/^(flex|grid|p-|m-|w-|h-|bg-|text-|border-|rounded-|shadow-|overflow-|relative|absolute|fixed|hidden|block|inline|items-|justify-|gap-|space-)/.test(c)) {
+                return false;
+            }
+            return c.length > 1;
+        })
+            .slice(0, 3);
+        const classSelector = classes.length > 0 ? '.' + classes.join('.') : '';
+        return `${tag}${id}${classSelector}`;
+    }
+    function setTree(root) {
+        const newNodesById = {};
+        const newRootIds = [];
+        const newNodesByDomPath = {};
+        const newNodesByStableId = {};
+        const newExpandedIds = new Set();
+        function processNode(node, parentId) {
+            const id = generateId();
+            const classification = classifier.classify({
+                tagName: node.tagName,
+                id: node.id,
+                className: node.className,
+                computedStyles: node.computedStyles,
+                rect: node.rect,
+                parentTagName: parentId ? newNodesById[parentId]?.tagName ?? null : null,
+                childCount: node.childCount,
+                hasTextContent: !!node.textContent,
+                attributes: node.attributes
+            });
+            const selector = generateSelector(node);
+            const childIds = [];
+            for (const child of node.children || []) {
+                childIds.push(processNode(child, id));
+            }
+            const stableId = node.attributes?.['data-sdesign-id'] || null;
+            const treeNode = {
+                id,
+                tagName: node.tagName,
+                className: node.className,
+                selector,
+                classification,
+                parentId,
+                childIds,
+                depth: node.depth,
+                domPath: node.domPath,
+                stableId,
+                boundingRect: node.rect,
+                computedStyles: node.computedStyles,
+                isExpanded: node.depth < 2,
+                isVisible: true,
+                attributes: node.attributes,
+                textContent: node.textContent,
+                childCount: node.childCount
+            };
+            newNodesById[id] = treeNode;
+            newNodesByDomPath[node.domPath.join(',')] = id;
+            if (stableId) {
+                newNodesByStableId[stableId] = id;
+            }
+            if (node.depth < 2 && childIds.length > 0) {
+                newExpandedIds.add(id);
+            }
+            if (parentId === null) {
+                newRootIds.push(id);
+            }
+            return id;
+        }
+        processNode(root, null);
+        setState({
+            nodesById: newNodesById,
+            rootIds: newRootIds,
+            nodesByDomPath: newNodesByDomPath,
+            nodesByStableId: newNodesByStableId,
+            expandedIds: newExpandedIds
+        });
+    }
+    function expandToNode(id) {
+        const newExpandedIds = new Set(state.expandedIds);
+        let current = state.nodesById[id];
+        while (current?.parentId) {
+            newExpandedIds.add(current.parentId);
+            current = state.nodesById[current.parentId];
+        }
+        setState({ expandedIds: newExpandedIds });
+    }
+    function getNodeByDomPath(path) {
+        const id = state.nodesByDomPath[path.join(',')];
+        return id ? state.nodesById[id] ?? null : null;
+    }
+    function getNodeByStableId(stableId) {
+        const id = state.nodesByStableId[stableId];
+        return id ? state.nodesById[id] ?? null : null;
+    }
+    function getNodeById(id) {
+        return state.nodesById[id] ?? null;
+    }
+    function toggleExpanded(id) {
+        const newExpandedIds = new Set(state.expandedIds);
+        if (newExpandedIds.has(id)) {
+            newExpandedIds.delete(id);
+        }
+        else {
+            newExpandedIds.add(id);
+        }
+        setState({ expandedIds: newExpandedIds });
+    }
+    function clear() {
+        setState({
+            nodesById: {},
+            rootIds: [],
+            nodesByDomPath: {},
+            nodesByStableId: {},
+            expandedIds: new Set()
+        });
+    }
+    return {
+        getState,
+        setState,
+        subscribe,
+        setTree,
+        expandToNode,
+        getNodeByDomPath,
+        getNodeByStableId,
+        getNodeById,
+        toggleExpanded,
+        clear
+    };
+}

package/dist/builder/widget.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Default DOM widget for vanilla JS users
+ * Renders a complete chat interface - floating or inline
+ */
+import type { StateStore } from './state';
+import type { StreamClient } from './client';
+export type WidgetMode = 'floating' | 'inline';
+export type WidgetPosition = 'bottom-right' | 'bottom-left';
+export type WidgetTheme = 'light' | 'dark';
+export interface WidgetConfig {
+    mode?: WidgetMode;
+    position?: WidgetPosition;
+    startOpen?: boolean;
+    showTimestamps?: boolean;
+    showAvatars?: boolean;
+    theme?: WidgetTheme;
+    placeholder?: string;
+    title?: string;
+}
+export interface Widget {
+    root: HTMLElement;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    isOpen: () => boolean;
+    destroy: () => void;
+}
+export declare function createWidget(container: string | HTMLElement | null, state: StateStore, client: StreamClient, config?: WidgetConfig): Widget;
+//# sourceMappingURL=widget.d.ts.map

package/dist/builder/widget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget.d.ts","sourceRoot":"","sources":["../../src/builder/widget.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAW,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;AAC/C,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,aAAa,CAAC;AAC5D,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,MAAM,CAAC;AAE3C,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,MAAM,EAAE,MAAM,OAAO,CAAC;IACtB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,EACtC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,YAAY,EACpB,MAAM,GAAE,YAAiB,GACxB,MAAM,CA6MR"}