@moldable-ai/ui 0.2.19 → 0.2.20

package/dist/components/native-capabilities/bluetooth-panel.js

@@ -0,0 +1,470 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Binary, Bluetooth } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { NativeCapabilityBridgeError, connectMoldableBluetoothDevice, isMoldableBluetoothSupported, observeMoldableBluetoothNotifications, readMoldableBluetoothValue, requestMoldableBluetoothWithFallback, writeMoldableBluetoothValue, } from '../../lib/native-capabilities';
+import { Button } from '../ui/button';
+import { Input } from '../ui/input';
+import { Spinner } from '../ui/spinner';
+import { cleanupBluetoothSubscriptions, parseBluetoothHexBytes, } from './bluetooth-panel-helpers';
+import { CapabilityBadge } from './capability-badge';
+import { DeviceList, DeviceListEmpty, DeviceListItem } from './device-list';
+import { LiveIndicator } from './live-indicator';
+import { NativeCapabilityPanel, NativeCapabilityPanelAction, NativeCapabilityPanelContent, NativeCapabilityPanelHeader, NativeCapabilityPanelIcon, NativeCapabilityPanelTitle, } from './native-capability-panel';
+import { StreamLog, useStreamLog } from './stream-log';
+const HEX_DUMP_MAX_BYTES = 32;
+const BLUETOOTH_BASE_UUID_SUFFIX = '-0000-1000-8000-00805f9b34fb';
+function toError(cause) {
+    return cause instanceof Error ? cause : new Error(String(cause));
+}
+function isDismissedChooser(cause) {
+    return (cause instanceof NativeCapabilityBridgeError &&
+        (cause.code === 'cancelled' || cause.code === 'aborted'));
+}
+function asBytes(data) {
+    return data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+function viewBytes(view) {
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+function formatHexDump(bytes) {
+    if (bytes.byteLength === 0)
+        return '(empty)';
+    const shown = Array.from(bytes.subarray(0, HEX_DUMP_MAX_BYTES))
+        .map((byte) => byte.toString(16).padStart(2, '0').toUpperCase())
+        .join(' ');
+    const hidden = bytes.byteLength - HEX_DUMP_MAX_BYTES;
+    return hidden > 0 ? `${shown} +${hidden} more` : shown;
+}
+/** `0x2A19` for SIG-assigned UUIDs, middle-truncated hex for vendor ones. */
+function shortUuid(uuid) {
+    const value = uuid.toLowerCase();
+    if (value.startsWith('0000') && value.endsWith(BLUETOOTH_BASE_UUID_SUFFIX)) {
+        return `0x${value.slice(4, 8).toUpperCase()}`;
+    }
+    return value.length > 13 ? `${value.slice(0, 8)}…${value.slice(-4)}` : value;
+}
+function middleTruncate(uuid) {
+    return uuid.length > 22 ? `${uuid.slice(0, 13)}…${uuid.slice(-8)}` : uuid;
+}
+function characteristicKey(characteristic) {
+    return `${characteristic.serviceUuid}/${characteristic.uuid}`;
+}
+/** Web Bluetooth exposes `properties`; the structural type keeps it optional. */
+function describeProperties(characteristic) {
+    const flags = characteristic
+        .properties;
+    if (!flags)
+        return [];
+    const names = [];
+    if (flags.read)
+        names.push('read');
+    if (flags.write || flags.writeWithoutResponse)
+        names.push('write');
+    if (flags.notify)
+        names.push('notify');
+    if (flags.indicate)
+        names.push('indicate');
+    return names;
+}
+function requireWebCharacteristic(characteristic) {
+    if (!characteristic.characteristic) {
+        throw new Error('This characteristic has no Web Bluetooth handle.');
+    }
+    return characteristic.characteristic;
+}
+function observeGattDisconnect(transport, listener) {
+    if (transport.kind === 'web-bluetooth') {
+        transport.device.addEventListener('gattserverdisconnected', listener);
+        return () => transport.device.removeEventListener('gattserverdisconnected', listener);
+    }
+    transport.device.addEventListener('gattserverdisconnected', listener);
+    return () => transport.device.removeEventListener('gattserverdisconnected', listener);
+}
+async function discoverWebServices(connection, serviceUuid) {
+    const services = serviceUuid
+        ? [await connection.getPrimaryService(serviceUuid)]
+        : await connection.server.getPrimaryServices();
+    return Promise.all(services.map(async (service) => {
+        const characteristics = await service
+            .getCharacteristics()
+            .catch(() => []);
+        return {
+            uuid: service.uuid,
+            characteristics: characteristics.map((characteristic) => ({
+                serviceUuid: service.uuid,
+                uuid: characteristic.uuid,
+                properties: describeProperties(characteristic),
+                characteristic,
+            })),
+        };
+    }));
+}
+/**
+ * Bluetooth LE state machine behind `BluetoothPanel`. Handles both transports
+ * returned by `requestMoldableBluetoothWithFallback`: Web Bluetooth (GATT
+ * connection + service discovery) and the desktop bridge (UUID-addressed I/O
+ * on an already-connected device).
+ */
+export function useMoldableBluetooth(options = {}) {
+    const [status, setStatus] = useState('idle');
+    const [device, setDevice] = useState(null);
+    const [connection, setConnection] = useState(null);
+    const [services, setServices] = useState([]);
+    const [subscribedUuids, setSubscribedUuids] = useState([]);
+    const [disconnecting, setDisconnecting] = useState(false);
+    const [error, setError] = useState(null);
+    const { entries, append, clear } = useStreamLog();
+    const generationRef = useRef(0);
+    const transportRef = useRef(null);
+    const connectionRef = useRef(null);
+    const requestedServiceRef = useRef(undefined);
+    const subscriptionsRef = useRef(new Map());
+    const detachDeviceRef = useRef(null);
+    const disconnectingRef = useRef(false);
+    const unmountedRef = useRef(false);
+    const onValueRef = useRef(options.onValue);
+    onValueRef.current = options.onValue;
+    const reset = useCallback(async (bestEffort = false) => {
+        generationRef.current++;
+        const wasDisconnecting = disconnectingRef.current;
+        disconnectingRef.current = true;
+        try {
+            try {
+                await cleanupBluetoothSubscriptions(subscriptionsRef.current);
+            }
+            catch (cause) {
+                if (!unmountedRef.current) {
+                    setSubscribedUuids([...subscriptionsRef.current.keys()]);
+                }
+                if (!bestEffort)
+                    throw cause;
+            }
+            const transport = transportRef.current;
+            try {
+                if (transport?.kind === 'desktop-bridge') {
+                    await transport.device.disconnect();
+                }
+                else {
+                    connectionRef.current?.disconnect();
+                }
+            }
+            catch (cause) {
+                if (!bestEffort)
+                    throw cause;
+            }
+            detachDeviceRef.current?.();
+            detachDeviceRef.current = null;
+            transportRef.current = null;
+            connectionRef.current = null;
+            requestedServiceRef.current = undefined;
+            subscriptionsRef.current.clear();
+            if (!unmountedRef.current) {
+                setSubscribedUuids([]);
+                setDevice(null);
+                setConnection(null);
+                setServices([]);
+            }
+        }
+        finally {
+            disconnectingRef.current = wasDisconnecting;
+        }
+    }, []);
+    const disconnect = useCallback(async () => {
+        setDisconnecting(true);
+        setError(null);
+        try {
+            await reset();
+            setStatus('idle');
+        }
+        catch (cause) {
+            setError(toError(cause));
+        }
+        finally {
+            setDisconnecting(false);
+        }
+    }, [reset]);
+    const handleDisconnected = useCallback(() => {
+        if (disconnectingRef.current)
+            return;
+        void reset(true).then(() => {
+            if (unmountedRef.current)
+                return;
+            setStatus('idle');
+            append({ direction: 'info', data: 'Device disconnected' });
+        });
+    }, [append, reset]);
+    const handleDisconnectedRef = useRef(handleDisconnected);
+    handleDisconnectedRef.current = handleDisconnected;
+    const appendValue = useCallback((characteristic, value) => {
+        append({
+            direction: 'in',
+            data: `${shortUuid(characteristic.uuid)} ${formatHexDump(viewBytes(value))}`,
+        });
+        onValueRef.current?.(characteristic, value);
+    }, [append]);
+    const connect = useCallback(async () => {
+        const transport = transportRef.current;
+        if (!transport)
+            return;
+        const generation = generationRef.current;
+        setStatus('connecting');
+        setError(null);
+        try {
+            let discovered;
+            if (transport.kind === 'web-bluetooth') {
+                const nextConnection = await connectMoldableBluetoothDevice(transport.device);
+                if (generationRef.current !== generation) {
+                    nextConnection.disconnect();
+                    return;
+                }
+                connectionRef.current = nextConnection;
+                setConnection(nextConnection);
+                discovered = await discoverWebServices(nextConnection, requestedServiceRef.current);
+            }
+            else {
+                discovered = (await transport.device.getServices()).map((service) => ({
+                    uuid: service.uuid,
+                    characteristics: service.characteristicUuids.map((uuid) => ({
+                        serviceUuid: service.uuid,
+                        uuid,
+                        properties: [],
+                        characteristic: null,
+                    })),
+                }));
+            }
+            if (generationRef.current !== generation)
+                return;
+            setServices(discovered);
+            setStatus('connected');
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+            setStatus('error');
+        }
+    }, []);
+    const request = useCallback(async (serviceUuid) => {
+        setError(null);
+        try {
+            await reset();
+            const generation = generationRef.current;
+            const trimmed = serviceUuid?.trim() || undefined;
+            requestedServiceRef.current = trimmed;
+            setStatus('requesting');
+            if (!trimmed && !isMoldableBluetoothSupported()) {
+                throw new Error('The desktop Bluetooth chooser needs a service UUID to scan.');
+            }
+            const transport = await requestMoldableBluetoothWithFallback(trimmed
+                ? {
+                    filters: [{ services: [trimmed] }],
+                    optionalServices: [trimmed],
+                }
+                : { acceptAllDevices: true });
+            if (generationRef.current !== generation) {
+                if (transport.kind === 'desktop-bridge') {
+                    await transport.device.disconnect().catch(() => undefined);
+                }
+                else {
+                    transport.device.gatt?.disconnect();
+                }
+                return;
+            }
+            transportRef.current = transport;
+            setDevice(transport.device);
+            detachDeviceRef.current = observeGattDisconnect(transport, () => {
+                handleDisconnectedRef.current();
+            });
+            await connect();
+        }
+        catch (cause) {
+            if (isDismissedChooser(cause)) {
+                setStatus('idle');
+                return;
+            }
+            if (unmountedRef.current)
+                return;
+            setError(toError(cause));
+            setStatus(transportRef.current ? 'connected' : 'error');
+        }
+    }, [connect, reset]);
+    const read = useCallback(async (characteristic) => {
+        const transport = transportRef.current;
+        if (!transport)
+            return;
+        const generation = generationRef.current;
+        setError(null);
+        try {
+            const value = transport.kind === 'desktop-bridge'
+                ? await transport.device.read(characteristic.serviceUuid, characteristic.uuid)
+                : await readMoldableBluetoothValue(requireWebCharacteristic(characteristic));
+            if (generationRef.current !== generation)
+                return;
+            appendValue(characteristic, value);
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+        }
+    }, [appendValue]);
+    const subscribe = useCallback(async (characteristic) => {
+        const transport = transportRef.current;
+        const key = characteristicKey(characteristic);
+        if (!transport || subscriptionsRef.current.has(key))
+            return;
+        const generation = generationRef.current;
+        setError(null);
+        try {
+            let stop;
+            if (transport.kind === 'desktop-bridge') {
+                stop = await transport.device.observe(characteristic.serviceUuid, characteristic.uuid, (value) => appendValue(characteristic, value));
+            }
+            else {
+                const target = requireWebCharacteristic(characteristic);
+                stop = await observeMoldableBluetoothNotifications(target, () => {
+                    if (target.value)
+                        appendValue(characteristic, target.value);
+                });
+            }
+            if (generationRef.current !== generation) {
+                await stop().catch(() => undefined);
+                return;
+            }
+            subscriptionsRef.current.set(key, stop);
+            setSubscribedUuids((previous) => previous.includes(key) ? previous : [...previous, key]);
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+        }
+    }, [appendValue]);
+    const unsubscribe = useCallback(async (characteristic) => {
+        const key = characteristicKey(characteristic);
+        const stop = subscriptionsRef.current.get(key);
+        if (!stop)
+            return;
+        setError(null);
+        try {
+            await stop();
+            if (subscriptionsRef.current.get(key) !== stop)
+                return;
+            subscriptionsRef.current.delete(key);
+            setSubscribedUuids((previous) => previous.filter((value) => value !== key));
+        }
+        catch (cause) {
+            setError(toError(cause));
+        }
+    }, []);
+    const write = useCallback(async (characteristic, bytes) => {
+        const transport = transportRef.current;
+        if (!transport)
+            return;
+        const generation = generationRef.current;
+        setError(null);
+        try {
+            if (transport.kind === 'desktop-bridge') {
+                await transport.device.write(characteristic.serviceUuid, characteristic.uuid, bytes);
+            }
+            else {
+                await writeMoldableBluetoothValue(requireWebCharacteristic(characteristic), bytes, 'automatic');
+            }
+            if (generationRef.current !== generation)
+                return;
+            append({
+                direction: 'out',
+                data: `${shortUuid(characteristic.uuid)} ${formatHexDump(asBytes(bytes))}`,
+            });
+        }
+        catch (cause) {
+            if (generationRef.current !== generation)
+                return;
+            setError(toError(cause));
+        }
+    }, [append]);
+    const writeHex = useCallback(async (characteristic, value) => {
+        try {
+            await write(characteristic, parseBluetoothHexBytes(value));
+        }
+        catch (cause) {
+            setError(toError(cause));
+        }
+    }, [write]);
+    useEffect(() => {
+        unmountedRef.current = false;
+        return () => {
+            unmountedRef.current = true;
+            void reset(true);
+        };
+    }, [reset]);
+    return {
+        status,
+        device,
+        connection,
+        disconnecting,
+        services,
+        subscribedUuids,
+        error,
+        entries,
+        request,
+        connect,
+        disconnect,
+        read,
+        subscribe,
+        unsubscribe,
+        write,
+        writeHex,
+        clearEntries: clear,
+    };
+}
+/**
+ * Bluetooth LE panel: scan (optionally scoped to a service UUID), connect,
+ * browse discovered characteristics, and read, write, or subscribe to values
+ * with a live hex log.
+ */
+function BluetoothPanel({ className, serviceUuid, onValue, ...props }) {
+    const bluetooth = useMoldableBluetooth({ onValue });
+    const [uuidInput, setUuidInput] = useState(serviceUuid ?? '');
+    const [writeValues, setWriteValues] = useState({});
+    const connected = bluetooth.status === 'connected';
+    const busy = bluetooth.status === 'requesting' || bluetooth.status === 'connecting';
+    const deviceName = bluetooth.device?.name || 'BLE device';
+    return (_jsxs(NativeCapabilityPanel, { "data-slot": "bluetooth-panel", "data-status": bluetooth.status, className: className, ...props, children: [_jsxs(NativeCapabilityPanelHeader, { children: [_jsx(NativeCapabilityPanelIcon, { children: _jsx(Bluetooth, {}) }), _jsx(NativeCapabilityPanelTitle, { children: "Bluetooth LE" }), _jsx(CapabilityBadge, { capability: "bluetooth" }), _jsx(NativeCapabilityPanelAction, { children: connected ? (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-muted-foreground inline-flex max-w-40 items-center rounded-full border px-2 py-0.5 text-[11px] font-medium", children: _jsx("span", { className: "truncate", children: deviceName }) }), _jsx(LiveIndicator, {}), _jsxs(Button, { size: "sm", variant: "outline", disabled: bluetooth.disconnecting, onClick: () => void bluetooth.disconnect(), children: [bluetooth.disconnecting ? _jsx(Spinner, {}) : null, bluetooth.disconnecting ? 'Disconnecting…' : 'Disconnect'] })] })) : (_jsxs(_Fragment, { children: [_jsx(Input, { value: uuidInput, onChange: (event) => setUuidInput(event.target.value), onKeyDown: (event) => {
+                                        if (event.key === 'Enter' && !busy) {
+                                            void bluetooth.request(uuidInput);
+                                        }
+                                    }, placeholder: "Service UUID (optional)", "aria-label": "Service UUID", disabled: busy, className: "h-8 w-44 font-mono text-xs md:text-xs" }), _jsxs(Button, { size: "sm", disabled: busy, onClick: () => void bluetooth.request(uuidInput), children: [busy ? _jsx(Spinner, {}) : null, bluetooth.status === 'requesting'
+                                            ? 'Scanning…'
+                                            : bluetooth.status === 'connecting'
+                                                ? 'Connecting…'
+                                                : 'Scan'] })] })) })] }), _jsx(NativeCapabilityPanelContent, { children: connected ? (_jsxs("div", { className: "animate-in fade-in space-y-4 duration-300 motion-reduce:animate-none", children: [bluetooth.services.length === 0 ? (_jsx(DeviceList, { children: _jsx(DeviceListEmpty, { icon: _jsx(Bluetooth, {}), children: "No GATT services discovered" }) })) : (bluetooth.services.map((service) => (_jsxs("section", { "data-slot": "bluetooth-service", className: "space-y-1.5", children: [_jsx("div", { className: "text-muted-foreground font-mono text-[10px] font-medium uppercase tracking-wider", children: middleTruncate(service.uuid) }), _jsx(DeviceList, { children: service.characteristics.length === 0 ? (_jsx(DeviceListEmpty, { children: "No characteristics" })) : (service.characteristics.map((characteristic) => {
+                                        const key = characteristicKey(characteristic);
+                                        const subscribed = bluetooth.subscribedUuids.includes(key);
+                                        const unknown = characteristic.properties.length === 0;
+                                        const canRead = unknown || characteristic.properties.includes('read');
+                                        const canWrite = unknown || characteristic.properties.includes('write');
+                                        const canNotify = unknown ||
+                                            characteristic.properties.includes('notify') ||
+                                            characteristic.properties.includes('indicate');
+                                        return (_jsx(DeviceListItem, { icon: _jsx(Binary, {}), name: _jsx("span", { className: "font-mono", children: shortUuid(characteristic.uuid) }), description: unknown
+                                                ? undefined
+                                                : characteristic.properties.join(' · '), action: _jsxs(_Fragment, { children: [canWrite ? (_jsxs(_Fragment, { children: [_jsx(Input, { value: writeValues[key] ?? '', onChange: (event) => setWriteValues((previous) => ({
+                                                                    ...previous,
+                                                                    [key]: event.target.value,
+                                                                })), onKeyDown: (event) => {
+                                                                    if (event.key === 'Enter') {
+                                                                        void bluetooth.writeHex(characteristic, writeValues[key] ?? '');
+                                                                    }
+                                                                }, placeholder: "01 A0 FF", "aria-label": `Hex value for ${shortUuid(characteristic.uuid)}`, className: "h-7 w-24 font-mono text-xs md:text-xs" }), _jsx(Button, { variant: "ghost", size: "xs", onClick: () => void bluetooth.writeHex(characteristic, writeValues[key] ?? ''), children: "Write" })] })) : null, canRead ? (_jsx(Button, { variant: "ghost", size: "xs", onClick: () => void bluetooth.read(characteristic), children: "Read" })) : null, canNotify ? (_jsx(Button, { variant: "outline", size: "xs", onClick: () => void (subscribed
+                                                            ? bluetooth.unsubscribe(characteristic)
+                                                            : bluetooth.subscribe(characteristic)), children: subscribed ? 'Stop' : 'Notify' })) : null] }) }, key));
+                                    })) })] }, service.uuid)))), bluetooth.error ? (_jsx("p", { className: "text-status-error text-xs", children: bluetooth.error.message })) : null, _jsx(StreamLog, { entries: bluetooth.entries, maxHeight: 200, emptyLabel: "Waiting for characteristic data" })] })) : (_jsx("div", { className: "animate-in fade-in flex flex-col items-center gap-3 py-6 text-center duration-300 motion-reduce:animate-none", children: busy ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { className: "text-muted-foreground" }), _jsx("p", { className: "text-muted-foreground text-xs", children: bluetooth.status === 'requesting'
+                                    ? 'Waiting for the device chooser…'
+                                    : 'Connecting to device…' })] })) : bluetooth.status === 'error' ? (_jsxs(_Fragment, { children: [_jsx("p", { className: "text-sm font-medium", children: "Bluetooth request failed" }), _jsx("p", { className: "text-muted-foreground max-w-64 text-xs", children: bluetooth.error?.message ??
+                                    'The Bluetooth request could not complete.' })] })) : (_jsxs(_Fragment, { children: [_jsx("div", { className: "text-muted-foreground bg-background shadow-xs flex size-10 items-center justify-center rounded-lg border [&_svg]:size-5", children: _jsx(Bluetooth, {}) }), _jsx("p", { className: "text-sm font-medium", children: "Not connected" }), _jsx("p", { className: "text-muted-foreground text-xs", children: "Scan for a nearby BLE device." })] })) })) })] }));
+}
+export { BluetoothPanel };

package/dist/components/native-capabilities/camera-preview.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+export type MoldableCameraStatus = 'idle' | 'starting' | 'live' | 'muted' | 'denied' | 'error';
+export interface UseMoldableCameraOptions {
+    /** Extra video constraints merged under the selected device. */
+    constraints?: MediaTrackConstraints;
+    onStreamChange?: (stream: MediaStream | null) => void;
+}
+/**
+ * Camera state machine behind `CameraPreview`. Use directly to build custom
+ * camera UI on the same permission/device/stream handling.
+ */
+export declare function useMoldableCamera(options?: UseMoldableCameraOptions): {
+    status: MoldableCameraStatus;
+    stream: MediaStream | null;
+    devices: MediaDeviceInfo[];
+    deviceId: string | null;
+    error: Error | null;
+    start: (nextDeviceId?: string) => Promise<void>;
+    stop: () => void;
+    selectDevice: (id: string) => void;
+    refreshDevices: () => Promise<void>;
+};
+export interface CameraPreviewProps extends React.ComponentProps<'div'> {
+    constraints?: MediaTrackConstraints;
+    /** Mirror the preview horizontally (natural for user-facing cameras). */
+    mirrored?: boolean;
+    /** Start the camera on mount. */
+    autoStart?: boolean;
+    /** When set, shows a shutter button and delivers PNG snapshots. */
+    onSnapshot?: (blob: Blob) => void;
+    onStreamChange?: (stream: MediaStream | null) => void;
+}
+/**
+ * Full-bleed live camera surface: black media well, hover scrim controls,
+ * device switching, permission and error states, optional snapshots.
+ */
+declare function CameraPreview({ className, constraints, mirrored, autoStart, onSnapshot, onStreamChange, ...props }: CameraPreviewProps): import("react/jsx-runtime").JSX.Element;
+export { CameraPreview };
+//# sourceMappingURL=camera-preview.d.ts.map

package/dist/components/native-capabilities/camera-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-preview.d.ts","sourceRoot":"","sources":["../../../src/components/native-capabilities/camera-preview.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAsB9B,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,UAAU,GACV,MAAM,GACN,OAAO,GACP,QAAQ,GACR,OAAO,CAAA;AAEX,MAAM,WAAW,wBAAwB;IACvC,gEAAgE;IAChE,WAAW,CAAC,EAAE,qBAAqB,CAAA;IACnC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAA;CACtD;AAuBD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B;;;;;;2BA+C9C,MAAM;;uBA2EvB,MAAM;;EA2Bd;AAED,MAAM,WAAW,kBAAmB,SAAQ,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC;IACrE,WAAW,CAAC,EAAE,qBAAqB,CAAA;IACnC,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,iCAAiC;IACjC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,mEAAmE;IACnE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IACjC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAA;CACtD;AAED;;;GAGG;AACH,iBAAS,aAAa,CAAC,EACrB,SAAS,EACT,WAAW,EACX,QAAe,EACf,SAAiB,EACjB,UAAU,EACV,cAAc,EACd,GAAG,KAAK,EACT,EAAE,kBAAkB,2CA+LpB;AAED,OAAO,EAAE,aAAa,EAAE,CAAA"}