@3driseai/3drise-viewer 0.1.1

package/dist/hooks/use3driseShader.js

@@ -0,0 +1,100 @@
+import { Color, Vector2 } from 'three';
+import { EFFECT_REGISTRY, buildUniformPrefix, } from '@3driseai/3drise-core';
+const warnedKeys = new Set();
+function warnOnce(key, message) {
+    if (warnedKeys.has(key))
+        return;
+    warnedKeys.add(key);
+    console.warn(message);
+}
+function writeUniformValue(uniformObj, def, raw) {
+    const value = raw === undefined ? def.default : raw;
+    switch (def.glslType) {
+        case 'float':
+        case 'int':
+            uniformObj.value = typeof value === 'number' ? value : Number(value) || 0;
+            return;
+        case 'bool':
+            uniformObj.value = Boolean(value);
+            return;
+        case 'vec2': {
+            const v = Array.isArray(value) ? value : [0, 0];
+            if (uniformObj.value instanceof Vector2) {
+                uniformObj.value.set(v[0] ?? 0, v[1] ?? 0);
+            }
+            else {
+                uniformObj.value = new Vector2(v[0] ?? 0, v[1] ?? 0);
+            }
+            return;
+        }
+        case 'vec3': {
+            if (def.control.kind === 'color') {
+                if (uniformObj.value instanceof Color) {
+                    if (typeof value === 'string')
+                        uniformObj.value.set(value);
+                    else if (Array.isArray(value))
+                        uniformObj.value.setRGB(value[0] ?? 1, value[1] ?? 1, value[2] ?? 1);
+                }
+                else {
+                    uniformObj.value = typeof value === 'string' ? new Color(value) : new Color(1, 1, 1);
+                }
+                return;
+            }
+            const v = Array.isArray(value) ? value : [0, 0, 0];
+            uniformObj.value = [v[0] ?? 0, v[1] ?? 0, v[2] ?? 0];
+            return;
+        }
+        case 'vec4': {
+            const v = Array.isArray(value) ? value : [0, 0, 0, 0];
+            uniformObj.value = [v[0] ?? 0, v[1] ?? 0, v[2] ?? 0, v[3] ?? 0];
+            return;
+        }
+        default:
+            uniformObj.value = value;
+    }
+}
+export function update3driseShaderUniforms(uniforms, effects, time, pointer, options) {
+    if (!uniforms)
+        return;
+    const tu = uniforms.u_time;
+    if (tu)
+        tu.value = time;
+    const pu = uniforms.u_pointer;
+    if (pu) {
+        if (pu.value instanceof Vector2)
+            pu.value.set(pointer.x, pointer.y);
+        else
+            pu.value = new Vector2(pointer.x, pointer.y);
+    }
+    if (options?.pointerRadius !== undefined) {
+        const ru = uniforms.uPointerEffectRadius;
+        if (ru)
+            ru.value = options.pointerRadius;
+    }
+    if (!effects || !Array.isArray(effects))
+        return;
+    for (const eff of effects) {
+        if (!eff || !eff.enabled)
+            continue;
+        const desc = EFFECT_REGISTRY[eff.type];
+        if (!desc) {
+            warnOnce(`unknown:${eff.type}`, `[3drise] unknown effect type "${eff.type}"; skipping uniform writes`);
+            continue;
+        }
+        const prefix = buildUniformPrefix(eff.instanceId);
+        for (const [key, def] of Object.entries(desc.uniforms)) {
+            const uniformName = `${prefix}${key}`;
+            const u = uniforms[uniformName];
+            if (!u) {
+                warnOnce(`missing:${uniformName}`, `[3drise] uniform "${uniformName}" not found on material; skipping`);
+                continue;
+            }
+            writeUniformValue(u, def, eff.values?.[key]);
+        }
+    }
+}
+export function use3driseShader(effects) {
+    return (uniforms, time, pointer) => {
+        update3driseShaderUniforms(uniforms, effects, time, pointer);
+    };
+}

package/dist/hooks/useAnimationEvents.d.ts

@@ -0,0 +1,10 @@
+import type { AnimationEvent } from '@3driseai/3drise-core';
+interface AnimationEventHandlers {
+    onSequenceStart?: (event: AnimationEvent) => void;
+    onSequenceEnd?: (event: AnimationEvent) => void;
+    onStepStart?: (event: AnimationEvent) => void;
+    onStepEnd?: (event: AnimationEvent) => void;
+}
+export declare const useAnimationEvents: (handlers: AnimationEventHandlers) => void;
+export {};
+//# sourceMappingURL=useAnimationEvents.d.ts.map

package/dist/hooks/useAnimationEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimationEvents.d.ts","sourceRoot":"","sources":["../../src/hooks/useAnimationEvents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,UAAU,sBAAsB;IAC5B,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IAClD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IAChD,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;CAC/C;AAQD,eAAO,MAAM,kBAAkB,GAAI,UAAU,sBAAsB,KAAG,IAwCrE,CAAC"}

package/dist/hooks/useAnimationEvents.js

@@ -0,0 +1,49 @@
+import { useEffect, useRef } from 'react';
+import { AnimationsManager } from '@3driseai/3drise-core';
+const DEBUG_ANIMATION_EVENTS = false;
+const debugLog = (...args) => {
+    if (DEBUG_ANIMATION_EVENTS) {
+        console.log('[useAnimationEvents]', ...args);
+    }
+};
+export const useAnimationEvents = (handlers) => {
+    const ref = useRef(handlers);
+    ref.current = handlers;
+    useEffect(() => {
+        debugLog('subscribing', {
+            sequenceStart: !!handlers.onSequenceStart,
+            sequenceEnd: !!handlers.onSequenceEnd,
+            stepStart: !!handlers.onStepStart,
+            stepEnd: !!handlers.onStepEnd,
+        });
+        const wrap = (key) => (event) => {
+            debugLog('event received', {
+                key,
+                sequenceId: event.sequenceId,
+                stepIndex: event.stepIndex,
+                transitionCount: event.step?.transitions?.length ?? 0,
+            });
+            ref.current[key]?.(event);
+        };
+        const ss = wrap('onSequenceStart');
+        const se = wrap('onSequenceEnd');
+        const ts = wrap('onStepStart');
+        const te = wrap('onStepEnd');
+        if (handlers.onSequenceStart)
+            AnimationsManager.on('sequenceStart', ss);
+        if (handlers.onSequenceEnd)
+            AnimationsManager.on('sequenceEnd', se);
+        if (handlers.onStepStart)
+            AnimationsManager.on('stepStart', ts);
+        if (handlers.onStepEnd)
+            AnimationsManager.on('stepEnd', te);
+        return () => {
+            debugLog('unsubscribing');
+            AnimationsManager.off('sequenceStart', ss);
+            AnimationsManager.off('sequenceEnd', se);
+            AnimationsManager.off('stepStart', ts);
+            AnimationsManager.off('stepEnd', te);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+};

package/dist/hooks/useCameraAnimation.d.ts

@@ -0,0 +1,35 @@
+import type { PerspectiveCamera } from 'three';
+import { type CameraState, type QuaternionArray, type Vector3Array } from "@3driseai/3drise-core";
+interface UseCameraAnimationOptions {
+    autoAnimate?: boolean;
+    defaultDuration?: number;
+    defaultEase?: string;
+    onAnimationStart?: () => void;
+    onAnimationComplete?: () => void;
+    onAnimationUpdate?: () => void;
+}
+interface CameraAnimationTarget {
+    position?: Vector3Array;
+    orientation?: QuaternionArray | Vector3Array;
+    fov?: number;
+    near?: number;
+    far?: number;
+}
+export declare const useCameraAnimation: (options?: UseCameraAnimationOptions, cameraState?: CameraState) => {
+    cameraState: CameraState;
+    isAnimating: () => boolean;
+    animateHandlers: (pointer: {
+        x: number;
+        y: number;
+    }) => void;
+    animateCamera: (target: CameraAnimationTarget, duration?: number, ease?: string, lookAtTarget?: Vector3Array) => Promise<void>;
+    animateToPosition: (position: Vector3Array, duration?: number, ease?: string) => Promise<void>;
+    animateToOrientation: (orientation: QuaternionArray, duration?: number, ease?: string) => Promise<void>;
+    animateToFov: (fov: number, duration?: number, ease?: string) => Promise<void>;
+    lookAt: (target: Vector3Array, animated?: boolean, duration?: number, ease?: string) => Promise<void>;
+    orbitAroundTarget: (target: Vector3Array, radius: number, startAngle?: number, endAngle?: number, duration?: number, ease?: string) => Promise<void>;
+    killAnimation: () => void;
+    camera: PerspectiveCamera | null;
+};
+export default useCameraAnimation;
+//# sourceMappingURL=useCameraAnimation.d.ts.map

package/dist/hooks/useCameraAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCameraAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/useCameraAnimation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAK/C,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAClG,UAAU,yBAAyB;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC9B,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;CAClC;AAED,UAAU,qBAAqB;IAC3B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,WAAW,CAAC,EAAE,eAAe,GAAG,YAAY,CAAC;IAC7C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CAChB;AAGD,eAAO,MAAM,kBAAkB,GAAI,UAAS,yBAA8B,EAAE,cAAa,WAAuB,KAAG;IAC3G,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,MAAM,OAAO,CAAC;IAC3B,eAAe,EAAE,CAAC,OAAO,EAAE;QACvB,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;KACb,KAAK,IAAI,CAAC;IACX,aAAa,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/H,iBAAiB,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/F,oBAAoB,EAAE,CAAC,WAAW,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxG,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/E,MAAM,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtG,iBAAiB,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrJ,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC;CA8QxC,CAAC;AACF,eAAe,kBAAkB,CAAC"}

package/dist/hooks/useCameraAnimation.js

@@ -0,0 +1,277 @@
+import { useRef, useEffect } from 'react';
+import { Quaternion } from 'three';
+import gsap from 'gsap';
+import { useMouseHandlers } from './useMouseHandlers.js';
+import { useOrbitControls } from './useOrbitControls.js';
+import cameraManager from '../utils/CameraSingleton.js';
+export const useCameraAnimation = (options = {}, cameraState = {}) => {
+    const { autoAnimate = true, defaultDuration = 2, defaultEase = "power2.out", onAnimationStart, onAnimationComplete, onAnimationUpdate } = options;
+    // const cameraState = useAppSelector(selectCamera);
+    const { interpolateProperty } = useMouseHandlers();
+    const orbitControls = useOrbitControls();
+    const cameraRef = useRef(null);
+    const animationRef = useRef(null);
+    const isAnimatingRef = useRef(false);
+    const handlers = cameraState.mouseMove;
+    // Keep cameraRef synced with the singleton. The hook may be initialized
+    // before the host component's effect calls cameraManager.setCamera(...),
+    // so a one-shot backfill races and leaves the ref null in production.
+    useEffect(() => {
+        cameraRef.current = cameraManager.getCamera();
+        return cameraManager.subscribe(() => {
+            cameraRef.current = cameraManager.getCamera();
+        });
+    }, []);
+    // Kill any running animation
+    const killAnimation = () => {
+        if (animationRef.current) {
+            animationRef.current.kill();
+            animationRef.current = null;
+        }
+        isAnimatingRef.current = false;
+    };
+    // Animate camera to target values
+    const animateCamera = (target, duration = defaultDuration, ease = defaultEase, lookAtTarget) => {
+        const cam = cameraRef.current;
+        // console.log("animateCamera called with cam:", cam);
+        if (!cam)
+            return Promise.resolve();
+        // Kill any existing animation
+        killAnimation();
+        // console.log('animateCamera', duration, ease)
+        return new Promise((resolve) => {
+            // console.log("Animating camera with target:", target, "duration:", duration, "ease:", ease);
+            const timeline = gsap.timeline({
+                onStart: () => {
+                    isAnimatingRef.current = true;
+                    onAnimationStart?.();
+                },
+                onUpdate: () => {
+                    // Update projection matrix if FOV changed
+                    if (target.fov !== undefined || target.near !== undefined || target.far !== undefined) {
+                        cam.updateProjectionMatrix();
+                    }
+                    onAnimationUpdate?.();
+                },
+                onComplete: () => {
+                    isAnimatingRef.current = false;
+                    animationRef.current = null;
+                    onAnimationComplete?.();
+                    resolve();
+                }
+            });
+            // Animate position
+            if (target.position) {
+                console.log("Animating camera to position:", target.position, duration, ease);
+                timeline.to(cam.position, {
+                    x: target.position[0],
+                    y: target.position[1],
+                    z: target.position[2],
+                    duration,
+                    ease
+                }, 0);
+            }
+            // Animate orientation
+            if (target.orientation) {
+                if (target.orientation.length === 3) {
+                    // Euler angles
+                    timeline.to(cam.rotation, {
+                        x: target.orientation[0],
+                        y: target.orientation[1],
+                        z: target.orientation[2],
+                        duration,
+                        ease
+                    }, 0);
+                }
+                else if (target.orientation.length === 4) {
+                    // Quaternion - convert to current quaternion and animate
+                    const targetQuat = new Quaternion(target.orientation[0], target.orientation[1], target.orientation[2], target.orientation[3]);
+                    const currentQuat = cam.quaternion.clone();
+                    timeline.to({ t: 0 }, {
+                        t: 1,
+                        duration,
+                        ease,
+                        onUpdate: function () {
+                            const t = this.targets()[0].t;
+                            cam.quaternion.slerpQuaternions(currentQuat, targetQuat, t);
+                        }
+                    }, 0);
+                }
+            }
+            // Animate FOV
+            if (target.fov !== undefined) {
+                timeline.to(cam, {
+                    fov: target.fov,
+                    duration,
+                    ease
+                }, 0);
+            }
+            // Animate clipping planes
+            if (target.near !== undefined) {
+                timeline.to(cam, {
+                    near: target.near,
+                    duration,
+                    ease
+                }, 0);
+            }
+            if (target.far !== undefined) {
+                timeline.to(cam, {
+                    far: target.far,
+                    duration,
+                    ease
+                }, 0);
+            }
+            // If lookAt target provided, animate the controls.target
+            // console.log("Animating camera with lookAtTarget:", lookAtTarget, orbitControls);
+            if (lookAtTarget && orbitControls) {
+                timeline.to(orbitControls.target, {
+                    x: lookAtTarget[0],
+                    y: lookAtTarget[1],
+                    z: lookAtTarget[2],
+                    duration,
+                    ease
+                }, 0);
+            }
+            animationRef.current = timeline;
+        });
+    };
+    // Animate to position
+    const animateToPosition = (position, duration, ease) => {
+        return animateCamera({ position }, duration, ease);
+    };
+    const applyInterpolatedValue = (property, interpolatedValue, valueType) => {
+        switch (valueType) {
+            case 'vector3':
+                if (Array.isArray(interpolatedValue)) {
+                    cameraRef.current[property].set(interpolatedValue[0], interpolatedValue[1], interpolatedValue[2]);
+                }
+                break;
+            case 'number':
+                cameraRef.current[property] = interpolatedValue;
+                break;
+            default:
+                break;
+        }
+    };
+    // Animate to orientation
+    const animateToOrientation = (orientation, duration, ease) => {
+        return animateCamera({ orientation }, duration, ease);
+    };
+    const animateHandlers = (pointer) => {
+        // if (!handlers?.onMouseMove?.enabled || !handlers.onMouseMove.properties.length || !cameraRef.current) {
+        //   return;
+        // }
+        // handlers.onMouseMove.properties.forEach((props) => {
+        //   const { property, propertySettings } = props;
+        //   const { min: minValue, max: maxValue, axis, sensitivity = 1, inverted = false } = propertySettings;
+        //   // Determine base value and property type
+        //   let baseValue = (cameraState as any)[property];
+        //   if (!baseValue) return;
+        //   const interpolatedValue = interpolateProperty(
+        //     baseValue,
+        //     minValue,
+        //     maxValue,
+        //     pointer,
+        //     axis,
+        //     sensitivity,
+        //     inverted
+        //   );
+        //   const valueType = getType(property, interpolatedValue);
+        //   // Update cam directly
+        //   if ((cameraRef.current as any)[property] !== undefined) {
+        //     applyInterpolatedValue(property, interpolatedValue, valueType);
+        //   }
+        // });
+    };
+    // Animate FOV
+    const animateToFov = (fov, duration, ease) => {
+        return animateCamera({ fov }, duration, ease);
+    };
+    // Look at target
+    const lookAt = (target, animated = autoAnimate, duration, ease) => {
+        const cam = cameraRef.current;
+        if (!cam)
+            return Promise.resolve();
+        if (!animated && target.length >= 3) {
+            cam.lookAt(target[0], target[1], target[2]);
+            return Promise.resolve();
+        }
+        // Calculate target rotation for animation
+        if (target.length < 3)
+            return Promise.resolve();
+        const tempCamera = cam.clone();
+        tempCamera.lookAt(target[0], target[1], target[2]);
+        const targetOrientation = [
+            tempCamera.rotation.x,
+            tempCamera.rotation.y,
+            tempCamera.rotation.z,
+            1
+        ];
+        return animateToOrientation(targetOrientation, duration, ease);
+    };
+    // Orbit around target
+    const orbitAroundTarget = (target, radius, startAngle = 0, endAngle = Math.PI * 2, duration, ease) => {
+        const cam = cameraRef.current;
+        if (!cam)
+            return Promise.resolve();
+        killAnimation();
+        return new Promise((resolve) => {
+            const timeline = gsap.timeline({
+                onStart: () => {
+                    isAnimatingRef.current = true;
+                    onAnimationStart?.();
+                },
+                onComplete: () => {
+                    isAnimatingRef.current = false;
+                    animationRef.current = null;
+                    onAnimationComplete?.();
+                    resolve();
+                }
+            });
+            timeline.to({ angle: startAngle }, {
+                angle: endAngle,
+                duration: duration || defaultDuration,
+                ease: ease || defaultEase,
+                onUpdate: function () {
+                    if (target.length < 3)
+                        return;
+                    const angle = this.targets()[0].angle;
+                    const x = target[0] + Math.cos(angle) * radius;
+                    const z = target[2] + Math.sin(angle) * radius;
+                    cam.position.set(x, cam.position.y, z);
+                    cam.lookAt(target[0], target[1], target[2]);
+                    onAnimationUpdate?.();
+                }
+            });
+            animationRef.current = timeline;
+        });
+    };
+    // Check if camera is currently animating
+    const isAnimating = () => {
+        return isAnimatingRef.current;
+    };
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            killAnimation();
+        };
+    }, []);
+    return {
+        // State
+        cameraState,
+        isAnimating,
+        animateHandlers,
+        // Animation methods
+        animateCamera,
+        animateToPosition,
+        animateToOrientation,
+        animateToFov,
+        lookAt,
+        orbitAroundTarget,
+        // Control methods
+        killAnimation,
+        // Camera reference
+        camera: cameraRef.current
+    };
+};
+export default useCameraAnimation;

package/dist/hooks/useContinuousEffects.d.ts

@@ -0,0 +1,15 @@
+import type { CreatedObjectSettings, EffectState } from '@3driseai/3drise-core';
+import { Object3D } from "three";
+export interface UseContinuousEffectsOptions {
+    enabled?: boolean;
+    animateMaterial?: boolean;
+    hovered?: boolean;
+}
+export interface UseContinuousEffectsResult {
+    isPathAnimating: () => boolean;
+    effectStateRef: React.MutableRefObject<EffectState | null>;
+}
+export declare const DEBUG_CONTINUOUS_EFFECTS = false;
+export declare const useContinuousEffects: (objectSettings: CreatedObjectSettings | null, options: UseContinuousEffectsOptions, object: Object3D) => UseContinuousEffectsResult;
+export default useContinuousEffects;
+//# sourceMappingURL=useContinuousEffects.d.ts.map

package/dist/hooks/useContinuousEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContinuousEffects.d.ts","sourceRoot":"","sources":["../../src/hooks/useContinuousEffects.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEhF,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,MAAM,WAAW,2BAA2B;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,0BAA0B;IACvC,eAAe,EAAE,MAAM,OAAO,CAAC;IAC/B,cAAc,EAAE,KAAK,CAAC,gBAAgB,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CAC9D;AAMD,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AAM9C,eAAO,MAAM,oBAAoB,GAEjC,gBAAgB,qBAAqB,GAAG,IAAI,EAAE,SAAS,2BAAgC,EAAE,QAAQ,QAAQ,KAAG,0BAgK3G,CAAC;AACF,eAAe,oBAAoB,CAAC"}