@moldable-ai/ui 0.2.19 → 0.2.20

package/dist/lib/native-capabilities/serial-native.js

@@ -0,0 +1,181 @@
+import { NativeCapabilityBridgeError } from './bridge';
+import { bytesFromNativeDeviceResult, bytesWrittenFromNativeDeviceResult, closeMoldableNativeDevice, executeMoldableNativeDeviceOperation, openMoldableNativeDevice, } from './native-device-io';
+import { NativeDeviceLifecycle, isNativeDeviceDisconnect, } from './native-device-lifecycle';
+export class NativeMoldableSerialPort extends EventTarget {
+    descriptor;
+    readable = null;
+    writable = null;
+    handle;
+    closing;
+    lifecycle = new NativeDeviceLifecycle();
+    constructor(descriptor) {
+        super();
+        this.descriptor = descriptor;
+    }
+    get connected() {
+        return this.lifecycle.connected;
+    }
+    getInfo() {
+        return {
+            usbVendorId: this.descriptor.vendorId,
+            usbProductId: this.descriptor.productId,
+        };
+    }
+    async open(options) {
+        if (this.closing)
+            await this.closing;
+        if (this.handle && this.lifecycle.disconnected)
+            await this.close();
+        if (this.handle) {
+            throw new DOMException('Serial port is already open.', 'InvalidStateError');
+        }
+        if (options.bufferSize !== undefined) {
+            throw new NativeCapabilityBridgeError({
+                code: 'unsupported',
+                message: 'The native serial fallback does not support bufferSize.',
+                retryable: false,
+            });
+        }
+        const opened = await openMoldableNativeDevice('serial', this.descriptor.selector, {
+            baudRate: options.baudRate,
+            dataBits: options.dataBits,
+            stopBits: options.stopBits,
+            parity: options.parity,
+            flowControl: options.flowControl,
+        });
+        if (opened.kind !== 'serial')
+            throw new Error('Native device kind mismatch.');
+        this.handle = opened.handle;
+        this.lifecycle.didOpen();
+        this.readable = this.createReadable();
+        this.writable = this.createWritable();
+    }
+    async close() {
+        if (this.closing)
+            return this.closing;
+        if (!this.handle)
+            return;
+        const handle = this.handle;
+        const closing = closeMoldableNativeDevice('serial', handle)
+            .then(() => {
+            if (this.handle === handle) {
+                this.handle = undefined;
+                this.readable = null;
+                this.writable = null;
+                this.lifecycle.didClose();
+            }
+        })
+            .finally(() => {
+            if (this.closing === closing)
+                this.closing = undefined;
+        });
+        this.closing = closing;
+        return closing;
+    }
+    async forget() {
+        await this.close();
+    }
+    async getSignals() {
+        const result = await this.execute({ action: 'serialGetSignals' });
+        if (result.kind !== 'signals' ||
+            typeof result.dataCarrierDetect !== 'boolean' ||
+            typeof result.clearToSend !== 'boolean' ||
+            typeof result.ringIndicator !== 'boolean' ||
+            typeof result.dataSetReady !== 'boolean') {
+            throw new NativeCapabilityBridgeError({
+                code: 'invalid_response',
+                message: 'Moldable returned invalid serial signals.',
+            });
+        }
+        return {
+            dataCarrierDetect: result.dataCarrierDetect,
+            clearToSend: result.clearToSend,
+            ringIndicator: result.ringIndicator,
+            dataSetReady: result.dataSetReady,
+        };
+    }
+    async setSignals(signals) {
+        await this.execute({
+            action: 'serialSetSignals',
+            dataTerminalReady: signals.dataTerminalReady,
+            requestToSend: signals.requestToSend,
+            sendBreak: signals.break,
+        });
+    }
+    createReadable() {
+        return new ReadableStream({
+            pull: async (controller) => {
+                if (!this.handle) {
+                    controller.close();
+                    return;
+                }
+                try {
+                    const result = await this.execute({
+                        action: 'read',
+                        endpoint: null,
+                        length: 65_536,
+                        timeoutMs: 1_000,
+                        bulk: false,
+                    });
+                    const bytes = bytesFromNativeDeviceResult(result);
+                    if (bytes.length > 0)
+                        controller.enqueue(bytes);
+                }
+                catch (error) {
+                    if (error instanceof NativeCapabilityBridgeError &&
+                        error.code === 'timeout') {
+                        return;
+                    }
+                    controller.error(error);
+                }
+            },
+        });
+    }
+    createWritable() {
+        return new WritableStream({
+            write: async (data) => {
+                const result = await this.execute({
+                    action: 'write',
+                    endpoint: null,
+                    data: [...data],
+                    timeoutMs: 10_000,
+                    bulk: false,
+                });
+                if (bytesWrittenFromNativeDeviceResult(result) !== data.byteLength) {
+                    throw new NativeCapabilityBridgeError({
+                        code: 'host_error',
+                        message: 'The serial device accepted only part of the write.',
+                        retryable: true,
+                    });
+                }
+            },
+        });
+    }
+    async execute(operation) {
+        if (!this.handle) {
+            throw new NativeCapabilityBridgeError({
+                code: 'invalid_request',
+                message: 'Serial port is not open.',
+            });
+        }
+        if (this.lifecycle.disconnected) {
+            throw new NativeCapabilityBridgeError({
+                code: 'unavailable',
+                message: 'Serial device is disconnected.',
+                retryable: true,
+            });
+        }
+        try {
+            return await executeMoldableNativeDeviceOperation('serial', this.handle, operation);
+        }
+        catch (error) {
+            if (isNativeDeviceDisconnect(error)) {
+                this.lifecycle.didDisconnect(this, error);
+            }
+            throw error;
+        }
+    }
+}
+export function isNativeMoldableSerialPort(port) {
+    return port instanceof NativeMoldableSerialPort;
+}

package/dist/lib/native-capabilities/serial.d.ts

@@ -0,0 +1,76 @@
+export interface MoldableSerialOperationOptions {
+    signal?: AbortSignal;
+}
+export type MoldableBluetoothServiceUuid = number | string;
+export interface MoldableSerialPortFilter {
+    usbVendorId?: number;
+    usbProductId?: number;
+    bluetoothServiceClassId?: MoldableBluetoothServiceUuid;
+}
+export interface MoldableSerialOpenOptions {
+    baudRate: number;
+    dataBits?: 7 | 8;
+    stopBits?: 1 | 2;
+    parity?: 'none' | 'even' | 'odd';
+    bufferSize?: number;
+    flowControl?: 'none' | 'hardware';
+}
+export interface MoldableSerialPortInfo {
+    usbVendorId?: number;
+    usbProductId?: number;
+    bluetoothServiceClassId?: MoldableBluetoothServiceUuid;
+}
+export interface MoldableSerialInputSignals {
+    dataCarrierDetect: boolean;
+    clearToSend: boolean;
+    ringIndicator: boolean;
+    dataSetReady: boolean;
+}
+export interface MoldableSerialOutputSignals {
+    dataTerminalReady?: boolean;
+    requestToSend?: boolean;
+    break?: boolean;
+}
+/** Structural subset of the standard SerialPort interface used by the helpers. */
+export interface MoldableSerialPort extends EventTarget {
+    readonly readable: ReadableStream<Uint8Array> | null;
+    readonly writable: WritableStream<Uint8Array> | null;
+    readonly connected?: boolean;
+    getInfo(): MoldableSerialPortInfo;
+    open(options: MoldableSerialOpenOptions): Promise<void>;
+    close(): Promise<void>;
+    forget?(): Promise<void>;
+    getSignals(): Promise<MoldableSerialInputSignals>;
+    setSignals(signals: MoldableSerialOutputSignals): Promise<void>;
+}
+export interface MoldableSerialRequestOptions extends MoldableSerialOperationOptions {
+    filters?: readonly MoldableSerialPortFilter[];
+    allowedBluetoothServiceClassIds?: readonly MoldableBluetoothServiceUuid[];
+    /** Required when multiple native fallback ports match. Render a user choice. */
+    selectNativePort?: (ports: readonly MoldableSerialPort[]) => MoldableSerialPort | Promise<MoldableSerialPort>;
+}
+/** Returns true only when this WebView exposes the Web Serial entry point. */
+export declare function isMoldableSerialSupported(): boolean;
+/** Lists ports previously authorized through Web Serial. */
+export declare function getMoldableSerialPorts(): Promise<MoldableSerialPort[]>;
+/**
+ * Shows the browser's serial-port chooser. Call this directly from a user
+ * gesture. Aborting stops awaiting the result but may not dismiss the chooser.
+ */
+export declare function requestMoldableSerialPort(options?: MoldableSerialRequestOptions): Promise<MoldableSerialPort>;
+export declare function openMoldableSerialPort(port: MoldableSerialPort, options: MoldableSerialOpenOptions): Promise<void>;
+/** Closes a port after callers have released all stream readers and writers. */
+export declare function closeMoldableSerialPort(port: MoldableSerialPort): Promise<void>;
+/** Revokes the saved permission when the runtime supports SerialPort.forget(). */
+export declare function forgetMoldableSerialPort(port: MoldableSerialPort): Promise<void>;
+export declare function getMoldableSerialSignals(port: MoldableSerialPort): Promise<MoldableSerialInputSignals>;
+export declare function setMoldableSerialSignals(port: MoldableSerialPort, signals: MoldableSerialOutputSignals): Promise<void>;
+/** Reads one available serial chunk and always releases the stream reader. */
+export declare function readMoldableSerialPort(port: MoldableSerialPort, options?: MoldableSerialOperationOptions): Promise<ReadableStreamReadResult<Uint8Array>>;
+/**
+ * Writes one serial chunk and releases the stream writer. Aborting rejects the
+ * helper promptly and asks the stream to abort; the browser may finish an
+ * already-started hardware write before releasing the lock.
+ */
+export declare function writeMoldableSerialPort(port: MoldableSerialPort, data: Uint8Array, options?: MoldableSerialOperationOptions): Promise<void>;
+//# sourceMappingURL=serial.d.ts.map

package/dist/lib/native-capabilities/serial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serial.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/serial.ts"],"names":[],"mappings":"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"}

package/dist/lib/native-capabilities/serial.js

@@ -0,0 +1,215 @@
+import { assertMoldableNativeCapabilityAccess, requireMoldableNativeCapabilityAccess, } from './access';
+import { NativeCapabilityBridgeError } from './bridge';
+import { abortedDeviceIoError, awaitDeviceIoWithAbort, deviceIoError, unsupportedDeviceIoError, } from './device-io-errors';
+import { listMoldableNativeDevices } from './native-device-io';
+import { NativeMoldableSerialPort } from './serial-native';
+function assertNativeSerialFiltersSupported(options) {
+    if (options.allowedBluetoothServiceClassIds?.length ||
+        options.filters?.some((filter) => filter.bluetoothServiceClassId !== undefined)) {
+        throw new NativeCapabilityBridgeError({
+            code: 'unsupported',
+            message: 'The native serial fallback cannot match Bluetooth service identifiers on this platform.',
+            retryable: false,
+        });
+    }
+}
+function serialApi() {
+    const api = typeof navigator === 'undefined'
+        ? undefined
+        : navigator.serial;
+    if (!api)
+        throw unsupportedDeviceIoError('serial');
+    return api;
+}
+/** Returns true only when this WebView exposes the Web Serial entry point. */
+export function isMoldableSerialSupported() {
+    return (typeof navigator !== 'undefined' &&
+        !!navigator.serial);
+}
+/** Lists ports previously authorized through Web Serial. */
+export async function getMoldableSerialPorts() {
+    await assertMoldableNativeCapabilityAccess('serial');
+    if (!isMoldableSerialSupported()) {
+        throw unsupportedDeviceIoError('serial');
+    }
+    try {
+        return await serialApi().getPorts();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'enumerate', error);
+    }
+}
+/**
+ * Shows the browser's serial-port chooser. Call this directly from a user
+ * gesture. Aborting stops awaiting the result but may not dismiss the chooser.
+ */
+export async function requestMoldableSerialPort(options = {}) {
+    await requireMoldableNativeCapabilityAccess('serial', options);
+    if (!isMoldableSerialSupported()) {
+        assertNativeSerialFiltersSupported(options);
+        const descriptors = await listMoldableNativeDevices('serial', {
+            signal: options.signal,
+            ...(options.filters
+                ? {
+                    filters: options.filters.map(({ usbVendorId, usbProductId }) => ({
+                        vendorId: usbVendorId,
+                        productId: usbProductId,
+                    })),
+                }
+                : {}),
+        });
+        const ports = descriptors
+            .filter((descriptor) => !options.filters || options.filters.length === 0
+            ? true
+            : options.filters.some((filter) => (filter.usbVendorId === undefined ||
+                filter.usbVendorId === descriptor.vendorId) &&
+                (filter.usbProductId === undefined ||
+                    filter.usbProductId === descriptor.productId)))
+            .map((descriptor) => new NativeMoldableSerialPort(descriptor));
+        if (ports.length === 0) {
+            throw deviceIoError('serial', 'request', new DOMException('No matching serial port is available.', 'NotFoundError'));
+        }
+        if (ports.length === 1)
+            return ports[0];
+        if (!options.selectNativePort) {
+            throw deviceIoError('serial', 'request', new TypeError('A native port selector is required when multiple serial ports match.'));
+        }
+        const selected = await options.selectNativePort(ports);
+        if (!ports.includes(selected)) {
+            throw deviceIoError('serial', 'request', new TypeError('Invalid native serial selection.'));
+        }
+        return selected;
+    }
+    try {
+        return await awaitDeviceIoWithAbort(serialApi().requestPort({
+            ...(options.filters ? { filters: [...options.filters] } : {}),
+            ...(options.allowedBluetoothServiceClassIds
+                ? {
+                    allowedBluetoothServiceClassIds: [
+                        ...options.allowedBluetoothServiceClassIds,
+                    ],
+                }
+                : {}),
+        }), 'serial', 'request', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'request', error);
+    }
+}
+export async function openMoldableSerialPort(port, options) {
+    try {
+        await port.open(options);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'open', error);
+    }
+}
+/** Closes a port after callers have released all stream readers and writers. */
+export async function closeMoldableSerialPort(port) {
+    if (port.readable?.locked || port.writable?.locked) {
+        throw deviceIoError('serial', 'close', new DOMException('Release active serial stream readers and writers before closing.', 'InvalidStateError'));
+    }
+    try {
+        await port.close();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'close', error);
+    }
+}
+/** Revokes the saved permission when the runtime supports SerialPort.forget(). */
+export async function forgetMoldableSerialPort(port) {
+    if (typeof port.forget !== 'function') {
+        throw unsupportedDeviceIoError('serial');
+    }
+    try {
+        await port.forget();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'close', error);
+    }
+}
+export async function getMoldableSerialSignals(port) {
+    try {
+        return await port.getSignals();
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'read', error);
+    }
+}
+export async function setMoldableSerialSignals(port, signals) {
+    try {
+        await port.setSignals(signals);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'write', error);
+    }
+}
+/** Reads one available serial chunk and always releases the stream reader. */
+export async function readMoldableSerialPort(port, options = {}) {
+    if (options.signal?.aborted) {
+        throw abortedDeviceIoError('serial', 'read');
+    }
+    if (!port.readable) {
+        throw deviceIoError('serial', 'read', new DOMException('Serial port is not readable.', 'InvalidStateError'));
+    }
+    const reader = port.readable.getReader();
+    let aborted = false;
+    const handleAbort = () => {
+        aborted = true;
+        void reader.cancel().catch(() => undefined);
+    };
+    options.signal?.addEventListener('abort', handleAbort, { once: true });
+    try {
+        const result = await reader.read();
+        if (aborted)
+            throw abortedDeviceIoError('serial', 'read');
+        return result;
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'read', error);
+    }
+    finally {
+        options.signal?.removeEventListener('abort', handleAbort);
+        reader.releaseLock();
+    }
+}
+/**
+ * Writes one serial chunk and releases the stream writer. Aborting rejects the
+ * helper promptly and asks the stream to abort; the browser may finish an
+ * already-started hardware write before releasing the lock.
+ */
+export async function writeMoldableSerialPort(port, data, options = {}) {
+    if (options.signal?.aborted) {
+        throw abortedDeviceIoError('serial', 'write');
+    }
+    if (!port.writable) {
+        throw deviceIoError('serial', 'write', new DOMException('Serial port is not writable.', 'InvalidStateError'));
+    }
+    const writer = port.writable.getWriter();
+    let settled = false;
+    let abortPromise;
+    const writePromise = writer.write(data).finally(() => {
+        settled = true;
+    });
+    const handleAbort = () => {
+        abortPromise = writer.abort(new DOMException('Serial write aborted.', 'AbortError'));
+    };
+    options.signal?.addEventListener('abort', handleAbort, { once: true });
+    try {
+        await awaitDeviceIoWithAbort(writePromise, 'serial', 'write', options.signal);
+    }
+    catch (error) {
+        throw deviceIoError('serial', 'write', error);
+    }
+    finally {
+        options.signal?.removeEventListener('abort', handleAbort);
+        if (settled) {
+            writer.releaseLock();
+        }
+        else {
+            void Promise.allSettled([writePromise, abortPromise]).then(() => {
+                writer.releaseLock();
+            });
+        }
+    }
+}

package/dist/lib/native-capabilities/system-audio.d.ts

@@ -0,0 +1,127 @@
+import { type NativeCapabilityBridgeOptions } from './bridge';
+export declare const NATIVE_SYSTEM_AUDIO_MAX_REPLAY_FRAMES = 500;
+export declare const NATIVE_SYSTEM_AUDIO_PERMISSION_REQUEST_TIMEOUT_MS = 125000;
+export type MoldableSystemAudioCaptureMode = 'systemAudio' | 'systemMicrophone';
+export type MoldableSystemAudioSource = 'microphone' | 'system';
+export interface MoldableSystemAudioCapabilities {
+    osVersion: string;
+    osSupported: boolean;
+    microphonePermission: string;
+    canCaptureMicrophone: boolean;
+    screenCapturePermission: string;
+    systemAudioPermission: string;
+    systemAudioPermissionPreflight: string;
+    systemAudioPermissionRequest: string;
+    systemAudioPermissionGuidance: string;
+    screenCaptureKitAvailable: boolean;
+    coreAudioProcessTapAvailable: boolean;
+    defaultInputDeviceAvailable: boolean;
+    defaultInputDevice?: string | null;
+    defaultOutputDeviceAvailable: boolean;
+    defaultOutputDevice?: string | null;
+    canRequestSystemAudioPermission: boolean;
+    systemAudioPermissionRequired: boolean;
+    canCaptureSystemAudio: boolean;
+    architecture: Record<string, unknown>;
+    degradedReason?: string | null;
+}
+export interface MoldableSystemAudioCapabilityResult {
+    available: boolean;
+    capabilities: MoldableSystemAudioCapabilities;
+    requested?: boolean;
+}
+export interface MoldableSystemAudioSourceState {
+    active: boolean;
+    lastAudioAtMs?: number | null;
+    frameCount: number;
+    peak?: number | null;
+    rms?: number | null;
+}
+export interface MoldableSystemAudioStatus {
+    active: boolean;
+    sessionId?: string | null;
+    mode?: string | null;
+    desiredState?: string | null;
+    actualState?: string | null;
+    startedAtMs?: number | null;
+    lastHeartbeatAtMs?: number | null;
+    restartCount: number;
+    restartLimit: number;
+    restartWindowStartedAtMs?: number | null;
+    lastCrashReason?: string | null;
+    degradedReason?: string | null;
+    sidecarPid?: number | null;
+    sidecarMemoryBytes?: number | null;
+    memoryLimitBytes: number;
+    stopRequestedAtMs?: number | null;
+    stopReason?: string | null;
+    sources?: {
+        microphone: MoldableSystemAudioSourceState;
+        system: MoldableSystemAudioSourceState;
+    } | null;
+    aec?: Record<string, unknown> | null;
+}
+export interface MoldableSystemAudioStartResult {
+    started: true;
+    sessionId: string;
+}
+export type MoldableSystemAudioEvent = {
+    kind: 'started';
+    sessionId?: string;
+} | {
+    kind: 'stopped';
+    sessionId?: string;
+    reason?: string;
+} | {
+    kind: 'error';
+    sessionId?: string;
+    message?: string;
+    recoverable: boolean;
+} | {
+    kind: 'data';
+    sessionId: string;
+    sequence: number;
+    source: MoldableSystemAudioSource;
+    /** Interleaved signed 16-bit little-endian PCM. */
+    data: ArrayBuffer;
+    sampleRate?: number;
+    channels?: number;
+    frameCount?: number;
+    peak?: number;
+    rms?: number;
+};
+export type MoldableSystemAudioEventListener = (event: MoldableSystemAudioEvent) => void;
+export type UnsubscribeMoldableSystemAudioEvents = () => void;
+export interface MoldableSystemAudioStartOptions extends NativeCapabilityBridgeOptions {
+    captureMode?: MoldableSystemAudioCaptureMode;
+    sampleRate?: number;
+    channels?: number;
+}
+export interface MoldableSystemAudioStopOptions extends NativeCapabilityBridgeOptions {
+    reason?: string;
+}
+export interface MoldableSystemAudioReplayOptions extends NativeCapabilityBridgeOptions {
+    afterSequence?: number;
+    limit?: number;
+}
+export interface SubscribeMoldableSystemAudioEventsOptions {
+    signal?: AbortSignal;
+}
+/** Reads capture support and permission diagnostics without opening audio input. */
+export declare function getMoldableSystemAudioCapabilities(options?: NativeCapabilityBridgeOptions): Promise<MoldableSystemAudioCapabilityResult>;
+/** Requests system-audio permission. Call this only from a direct user action. */
+export declare function requestMoldableSystemAudioPermission(options?: NativeCapabilityBridgeOptions): Promise<MoldableSystemAudioCapabilityResult>;
+/** Starts an owner-scoped capture session from a direct user action. */
+export declare function startMoldableSystemAudioCapture(options?: MoldableSystemAudioStartOptions): Promise<MoldableSystemAudioStartResult>;
+/** Reads the status of the capture session owned by this app view. */
+export declare function getMoldableSystemAudioStatus(options?: NativeCapabilityBridgeOptions): Promise<MoldableSystemAudioStatus>;
+/** Stops only the capture session owned by this app view. */
+export declare function stopMoldableSystemAudioCapture(options?: MoldableSystemAudioStopOptions): Promise<boolean>;
+/** Replays recent frames through active event subscriptions after a sequence gap. */
+export declare function replayMoldableSystemAudioFrames(options?: MoldableSystemAudioReplayOptions): Promise<number>;
+/**
+ * Subscribes to lifecycle and source-separated PCM frames for this app view.
+ * Subscribe before starting capture so the first lifecycle event is observable.
+ */
+export declare function subscribeMoldableSystemAudioEvents(listener: MoldableSystemAudioEventListener, options?: SubscribeMoldableSystemAudioEventsOptions): UnsubscribeMoldableSystemAudioEvents;
+//# sourceMappingURL=system-audio.d.ts.map

package/dist/lib/native-capabilities/system-audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-audio.d.ts","sourceRoot":"","sources":["../../../src/lib/native-capabilities/system-audio.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,6BAA6B,EAGnC,MAAM,UAAU,CAAA;AAQjB,eAAO,MAAM,qCAAqC,MAAM,CAAA;AACxD,eAAO,MAAM,iDAAiD,SAAU,CAAA;AAExE,MAAM,MAAM,8BAA8B,GAAG,aAAa,GAAG,kBAAkB,CAAA;AAC/E,MAAM,MAAM,yBAAyB,GAAG,YAAY,GAAG,QAAQ,CAAA;AAE/D,MAAM,WAAW,+BAA+B;IAC9C,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,OAAO,CAAA;IACpB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,oBAAoB,EAAE,OAAO,CAAA;IAC7B,uBAAuB,EAAE,MAAM,CAAA;IAC/B,qBAAqB,EAAE,MAAM,CAAA;IAC7B,8BAA8B,EAAE,MAAM,CAAA;IACtC,4BAA4B,EAAE,MAAM,CAAA;IACpC,6BAA6B,EAAE,MAAM,CAAA;IACrC,yBAAyB,EAAE,OAAO,CAAA;IAClC,4BAA4B,EAAE,OAAO,CAAA;IACrC,2BAA2B,EAAE,OAAO,CAAA;IACpC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,4BAA4B,EAAE,OAAO,CAAA;IACrC,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,+BAA+B,EAAE,OAAO,CAAA;IACxC,6BAA6B,EAAE,OAAO,CAAA;IACtC,qBAAqB,EAAE,OAAO,CAAA;IAC9B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED,MAAM,WAAW,mCAAmC;IAClD,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,+BAA+B,CAAA;IAC7C,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,8BAA8B;IAC7C,MAAM,EAAE,OAAO,CAAA;IACf,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,wBAAwB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,gBAAgB,EAAE,MAAM,CAAA;IACxB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,OAAO,CAAC,EAAE;QACR,UAAU,EAAE,8BAA8B,CAAA;QAC1C,MAAM,EAAE,8BAA8B,CAAA;KACvC,GAAG,IAAI,CAAA;IACR,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CACrC;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,IAAI,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,wBAAwB,GAChC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACxD;IACE,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,OAAO,CAAA;CACrB,GACD;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,yBAAyB,CAAA;IACjC,mDAAmD;IACnD,IAAI,EAAE,WAAW,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAEL,MAAM,MAAM,gCAAgC,GAAG,CAC7C,KAAK,EAAE,wBAAwB,KAC5B,IAAI,CAAA;AACT,MAAM,MAAM,oCAAoC,GAAG,MAAM,IAAI,CAAA;AAE7D,MAAM,WAAW,+BACf,SAAQ,6BAA6B;IACrC,WAAW,CAAC,EAAE,8BAA8B,CAAA;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,8BACf,SAAQ,6BAA6B;IACrC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,gCACf,SAAQ,6BAA6B;IACrC,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,yCAAyC;IACxD,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAyQD,oFAAoF;AACpF,wBAAsB,kCAAkC,CACtD,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,mCAAmC,CAAC,CAc9C;AAED,kFAAkF;AAClF,wBAAsB,oCAAoC,CACxD,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,mCAAmC,CAAC,CAmB9C;AAED,wEAAwE;AACxE,wBAAsB,+BAA+B,CACnD,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,8BAA8B,CAAC,CAuBzC;AAED,sEAAsE;AACtE,wBAAsB,4BAA4B,CAChD,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,yBAAyB,CAAC,CAUpC;AAED,6DAA6D;AAC7D,wBAAsB,8BAA8B,CAClD,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAAC,OAAO,CAAC,CA2BlB;AAED,qFAAqF;AACrF,wBAAsB,+BAA+B,CACnD,OAAO,GAAE,gCAAqC,GAC7C,OAAO,CAAC,MAAM,CAAC,CAkCjB;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,gCAAgC,EAC1C,OAAO,GAAE,yCAA8C,GACtD,oCAAoC,CAgDtC"}