@shuji-bonji/rxjs-mcp 0.1.1 → 0.1.3

package/dist/data/patterns.js

@@ -0,0 +1,482 @@
+/**
+ * RxJS Pattern Templates Database
+ */
+export const patterns = {
+    'http-retry': {
+        name: 'HTTP Request with Retry',
+        description: 'Resilient HTTP requests with exponential backoff retry strategy',
+        useCase: 'Making API calls that may fail due to network issues or server errors',
+        operators: ['retry', 'retryWhen', 'delay', 'catchError', 'timer'],
+        code: `// HTTP request with exponential backoff retry
+import { throwError, timer, of } from 'rxjs';
+import { ajax } from 'rxjs/ajax';
+import { retryWhen, mergeMap, catchError, finalize } from 'rxjs/operators';
+
+const apiCall$ = ajax.getJSON('/api/data').pipe(
+  retryWhen(errors =>
+    errors.pipe(
+      mergeMap((error, index) => {
+        const retryAttempt = index + 1;
+        if (retryAttempt > 3) {
+          return throwError(() => error);
+        }
+        console.log(\`Retry attempt \${retryAttempt} after \${retryAttempt * 1000}ms\`);
+        return timer(retryAttempt * 1000); // Exponential backoff
+      })
+    )
+  ),
+  catchError(error => {
+    console.error('Failed after 3 retries:', error);
+    return of({ error: true, message: 'Service unavailable' });
+  }),
+  finalize(() => console.log('Request completed'))
+);`,
+        considerations: [
+            'Set a maximum retry count to prevent infinite retries',
+            'Use exponential backoff to avoid overwhelming the server',
+            'Provide fallback data on final failure',
+            'Log retry attempts for debugging',
+        ],
+    },
+    'search-typeahead': {
+        name: 'Search Typeahead with Debounce',
+        description: 'Efficient search implementation with debouncing and cancellation',
+        useCase: 'Real-time search suggestions as user types, minimizing API calls',
+        operators: ['debounceTime', 'distinctUntilChanged', 'switchMap', 'catchError', 'filter'],
+        code: `// Search typeahead implementation
+import { fromEvent, of, EMPTY } from 'rxjs';
+import { ajax } from 'rxjs/ajax';
+import { debounceTime, distinctUntilChanged, switchMap, catchError, filter, map } from 'rxjs/operators';
+
+const searchBox = document.getElementById('search');
+const search$ = fromEvent(searchBox, 'input').pipe(
+  map(event => (event.target as HTMLInputElement).value),
+  filter(query => query.length > 2), // Min 3 characters
+  debounceTime(300), // Wait for pause in typing
+  distinctUntilChanged(), // Ignore if same as previous
+  switchMap(query =>
+    ajax.getJSON(\`/api/search?q=\${query}\`).pipe(
+      catchError(error => {
+        console.error('Search failed:', error);
+        return of([]); // Return empty results on error
+      })
+    )
+  )
+);
+
+search$.subscribe(results => {
+  displaySearchResults(results);
+});`,
+        considerations: [
+            'Use debounceTime to wait for typing pause',
+            'distinctUntilChanged prevents duplicate searches',
+            'switchMap cancels previous requests automatically',
+            'Handle errors gracefully with empty results',
+            'Set minimum query length to reduce noise',
+        ],
+    },
+    'polling': {
+        name: 'Smart Polling with Backoff',
+        description: 'Periodic data fetching with error handling and dynamic intervals',
+        useCase: 'Regularly checking for updates while being respectful of server resources',
+        operators: ['interval', 'switchMap', 'retry', 'catchError', 'takeWhile', 'expand'],
+        code: `// Smart polling with exponential backoff on errors
+import { interval, timer, throwError, EMPTY } from 'rxjs';
+import { ajax } from 'rxjs/ajax';
+import { switchMap, retry, catchError, takeWhile, expand, tap } from 'rxjs/operators';
+
+let errorCount = 0;
+const maxErrors = 3;
+
+const polling$ = timer(0, 5000).pipe( // Start immediately, then every 5s
+  switchMap(() =>
+    ajax.getJSON('/api/status').pipe(
+      tap(() => errorCount = 0), // Reset on success
+      catchError(error => {
+        errorCount++;
+        if (errorCount >= maxErrors) {
+          console.error('Max errors reached, stopping polling');
+          return throwError(() => error);
+        }
+        console.log(\`Error \${errorCount}, backing off...\`);
+        return EMPTY; // Skip this emission
+      })
+    )
+  ),
+  takeWhile(() => errorCount < maxErrors)
+);
+
+// Alternative: Dynamic polling interval
+const dynamicPolling$ = ajax.getJSON('/api/data').pipe(
+  expand(data =>
+    timer(data.nextPollDelay || 5000).pipe(
+      switchMap(() => ajax.getJSON('/api/data'))
+    )
+  )
+);`,
+        considerations: [
+            'Implement backoff strategy for errors',
+            'Allow server to control polling rate',
+            'Stop polling after consecutive failures',
+            'Consider WebSockets for real-time requirements',
+            'Add jitter to prevent thundering herd',
+        ],
+    },
+    'websocket-reconnect': {
+        name: 'WebSocket with Auto-Reconnect',
+        description: 'Resilient WebSocket connection with automatic reconnection',
+        useCase: 'Maintaining persistent real-time connections with fallback',
+        operators: ['webSocket', 'retryWhen', 'delay', 'tap', 'catchError'],
+        code: `// WebSocket with automatic reconnection
+import { webSocket } from 'rxjs/webSocket';
+import { retry, retryWhen, delay, tap, catchError } from 'rxjs/operators';
+import { EMPTY } from 'rxjs';
+
+const createWebSocketSubject = () =>
+  webSocket({
+    url: 'ws://localhost:8080',
+    openObserver: {
+      next: () => console.log('WebSocket connected')
+    },
+    closeObserver: {
+      next: () => console.log('WebSocket disconnected')
+    }
+  });
+
+let socket$ = createWebSocketSubject();
+
+const resilientSocket$ = socket$.pipe(
+  retryWhen(errors =>
+    errors.pipe(
+      tap(err => console.log('WebSocket error, reconnecting...', err)),
+      delay(1000) // Wait before reconnecting
+    )
+  ),
+  catchError(err => {
+    console.error('WebSocket failed permanently:', err);
+    return EMPTY;
+  })
+);
+
+// Send messages
+const sendMessage = (message: any) => {
+  socket$.next(message);
+};
+
+// Subscribe to messages
+resilientSocket$.subscribe({
+  next: msg => console.log('Received:', msg),
+  error: err => console.error('Fatal error:', err),
+  complete: () => console.log('Connection closed')
+});`,
+        considerations: [
+            'Implement exponential backoff for reconnection',
+            'Queue messages during disconnection',
+            'Handle connection state in UI',
+            'Consider fallback to HTTP polling',
+            'Implement heartbeat/ping mechanism',
+        ],
+    },
+    'form-validation': {
+        name: 'Reactive Form Validation',
+        description: 'Real-time form validation with debouncing and async validators',
+        useCase: 'Validating form inputs with instant feedback and async checks',
+        operators: ['combineLatest', 'debounceTime', 'distinctUntilChanged', 'switchMap', 'map'],
+        code: `// Reactive form validation
+import { fromEvent, combineLatest, of, timer } from 'rxjs';
+import { debounceTime, distinctUntilChanged, switchMap, map, startWith } from 'rxjs/operators';
+import { ajax } from 'rxjs/ajax';
+
+const emailInput = document.getElementById('email') as HTMLInputElement;
+const passwordInput = document.getElementById('password') as HTMLInputElement;
+
+const email$ = fromEvent(emailInput, 'input').pipe(
+  map(e => (e.target as HTMLInputElement).value),
+  startWith(''),
+  debounceTime(300),
+  distinctUntilChanged(),
+  switchMap(email => {
+    if (!email) return of({ valid: false, error: 'Email required' });
+    if (!/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(email)) {
+      return of({ valid: false, error: 'Invalid email format' });
+    }
+    // Async validation - check if email exists
+    return ajax.getJSON(\`/api/check-email?email=\${email}\`).pipe(
+      map(result => ({
+        valid: !(result as any).exists,
+        error: (result as any).exists ? 'Email already taken' : null
+      }))
+    );
+  })
+);
+
+const password$ = fromEvent(passwordInput, 'input').pipe(
+  map(e => (e.target as HTMLInputElement).value),
+  startWith(''),
+  map(password => ({
+    valid: password.length >= 8,
+    error: password.length < 8 ? 'Password must be 8+ characters' : null
+  }))
+);
+
+const formValid$ = combineLatest([email$, password$]).pipe(
+  map(([email, password]) => ({
+    valid: email.valid && password.valid,
+    errors: {
+      email: email.error,
+      password: password.error
+    }
+  }))
+);
+
+formValid$.subscribe(validation => {
+  updateFormUI(validation);
+});`,
+        considerations: [
+            'Debounce async validators to reduce API calls',
+            'Show loading states during validation',
+            'Cache validation results when appropriate',
+            'Validate on blur for better UX',
+            'Consider field dependencies for complex forms',
+        ],
+    },
+    'state-management': {
+        name: 'Simple State Management',
+        description: 'Centralized state management using RxJS subjects',
+        useCase: 'Managing application state without external libraries',
+        operators: ['scan', 'shareReplay', 'distinctUntilChanged', 'pluck'],
+        code: `// Simple state management with RxJS
+import { BehaviorSubject, Subject, merge } from 'rxjs';
+import { scan, shareReplay, distinctUntilChanged, map } from 'rxjs/operators';
+
+interface AppState {
+  user: { id: string; name: string } | null;
+  items: Array<{ id: string; title: string }>;
+  loading: boolean;
+}
+
+// Initial state
+const initialState: AppState = {
+  user: null,
+  items: [],
+  loading: false
+};
+
+// Actions
+interface Action {
+  type: string;
+  payload?: any;
+}
+
+// Action creators
+const actions$ = new Subject<Action>();
+
+const setUser = (user: AppState['user']) =>
+  actions$.next({ type: 'SET_USER', payload: user });
+
+const addItem = (item: { id: string; title: string }) =>
+  actions$.next({ type: 'ADD_ITEM', payload: item });
+
+const setLoading = (loading: boolean) =>
+  actions$.next({ type: 'SET_LOADING', payload: loading });
+
+// Reducer
+const reducer = (state: AppState, action: Action): AppState => {
+  switch (action.type) {
+    case 'SET_USER':
+      return { ...state, user: action.payload };
+    case 'ADD_ITEM':
+      return { ...state, items: [...state.items, action.payload] };
+    case 'SET_LOADING':
+      return { ...state, loading: action.payload };
+    default:
+      return state;
+  }
+};
+
+// State stream
+const state$ = actions$.pipe(
+  scan(reducer, initialState),
+  shareReplay(1)
+);
+
+// Selectors
+const user$ = state$.pipe(
+  map(state => state.user),
+  distinctUntilChanged()
+);
+
+const items$ = state$.pipe(
+  map(state => state.items),
+  distinctUntilChanged()
+);
+
+const loading$ = state$.pipe(
+  map(state => state.loading),
+  distinctUntilChanged()
+);
+
+// Subscribe to state changes
+state$.subscribe(state => console.log('State updated:', state));`,
+        considerations: [
+            'Use BehaviorSubject for synchronous state access',
+            'Implement selectors with distinctUntilChanged',
+            'Consider immutability for predictable updates',
+            'Add middleware for side effects',
+            'Use shareReplay for multiple subscribers',
+        ],
+    },
+    'cache-refresh': {
+        name: 'Cache with Refresh Strategy',
+        description: 'Cached data with manual and automatic refresh capabilities',
+        useCase: 'Serving cached data instantly while fetching fresh data in background',
+        operators: ['shareReplay', 'merge', 'switchMap', 'startWith'],
+        code: `// Cache with refresh strategy
+import { BehaviorSubject, Subject, timer, merge } from 'rxjs';
+import { switchMap, shareReplay, startWith, tap } from 'rxjs/operators';
+import { ajax } from 'rxjs/ajax';
+
+class CachedDataService {
+  private refreshSubject = new Subject<void>();
+  private cache$ = new BehaviorSubject<any>(null);
+
+  // Automatic refresh every 30 seconds
+  private autoRefresh$ = timer(0, 30000);
+
+  // Combine manual and auto refresh triggers
+  private dataSource$ = merge(
+    this.autoRefresh$,
+    this.refreshSubject
+  ).pipe(
+    switchMap(() => ajax.getJSON('/api/data')),
+    tap(data => this.cache$.next(data)),
+    shareReplay({
+      bufferSize: 1,
+      refCount: true
+    })
+  );
+
+  // Public API
+  getData() {
+    const cached = this.cache$.value;
+    if (cached) {
+      // Return cached data immediately, fetch fresh in background
+      return merge(
+        of(cached),
+        this.dataSource$
+      ).pipe(
+        distinctUntilChanged((a, b) =>
+          JSON.stringify(a) === JSON.stringify(b)
+        )
+      );
+    }
+    return this.dataSource$;
+  }
+
+  refresh() {
+    this.refreshSubject.next();
+  }
+
+  // Cache invalidation
+  invalidate() {
+    this.cache$.next(null);
+    this.refresh();
+  }
+}`,
+        considerations: [
+            'Implement cache expiration policies',
+            'Handle stale-while-revalidate pattern',
+            'Consider memory limits for cache size',
+            'Add cache versioning for updates',
+            'Implement offline support with persistence',
+        ],
+    },
+};
+/**
+ * Adapt pattern for specific framework
+ */
+export function adaptPatternForFramework(pattern, framework) {
+    const adapted = { ...pattern };
+    if (framework === 'angular') {
+        adapted.code = `// Angular-specific implementation
+@Injectable({ providedIn: 'root' })
+export class RxJSPatternService implements OnDestroy {
+  private destroy$ = new Subject<void>();
+
+${pattern.code}
+
+  ngOnDestroy() {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
+}`;
+        adapted.considerations = [
+            ...pattern.considerations,
+            'Use async pipe in templates for auto-unsubscribe',
+            'Inject HttpClient instead of ajax',
+            'Consider using NgRx for complex state management',
+        ];
+    }
+    else if (framework === 'react') {
+        adapted.code = `// React Hook implementation
+import { useEffect, useState, useRef } from 'react';
+import { Subscription } from 'rxjs';
+
+export function useRxJSPattern() {
+  const [data, setData] = useState(null);
+  const subscription = useRef<Subscription>();
+
+  useEffect(() => {
+${pattern.code.split('\n').map(line => '    ' + line).join('\n')}
+
+    subscription.current = stream$.subscribe(setData);
+
+    return () => {
+      subscription.current?.unsubscribe();
+    };
+  }, []);
+
+  return data;
+}`;
+        adapted.considerations = [
+            ...pattern.considerations,
+            'Clean up subscriptions in useEffect return',
+            'Consider using a state management library',
+            'Be careful with closure stale values',
+        ];
+    }
+    else if (framework === 'vue') {
+        adapted.code = `// Vue 3 Composition API implementation
+import { ref, onBeforeUnmount } from 'vue';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+export function useRxJSPattern() {
+  const destroy$ = new Subject();
+  const data = ref(null);
+
+${pattern.code}
+
+  stream$.pipe(
+    takeUntil(destroy$)
+  ).subscribe(value => {
+    data.value = value;
+  });
+
+  onBeforeUnmount(() => {
+    destroy$.next();
+    destroy$.complete();
+  });
+
+  return { data };
+}`;
+        adapted.considerations = [
+            ...pattern.considerations,
+            'Use Composition API for better TypeScript support',
+            'Clean up in onBeforeUnmount',
+            'Consider Pinia for state management',
+        ];
+    }
+    return adapted;
+}
+//# sourceMappingURL=patterns.js.map

package/dist/data/patterns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.js","sourceRoot":"","sources":["../../src/data/patterns.ts"],"names":[],"mappings":"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"}

package/dist/data/rxjs-context.d.ts

@@ -0,0 +1,169 @@
+/**
+ * RxJS execution context for Worker thread
+ * Centralizes all RxJS imports and provides a safe execution context
+ */
+import { Observable, Subject, BehaviorSubject, ReplaySubject, AsyncSubject, connectable, of, from, interval, timer, range, generate, concat, merge, combineLatest, zip, forkJoin, race, partition, iif, defer, scheduled, throwError, firstValueFrom, lastValueFrom, map, scan, mergeScan, reduce, pairwise, groupBy, mergeMap, switchMap, concatMap, exhaustMap, expand, buffer, bufferTime, bufferCount, bufferWhen, bufferToggle, windowTime, window as windowOp, windowCount, windowToggle, windowWhen, filter, take, takeLast, takeWhile, skip, skipLast, skipWhile, skipUntil, first, last, elementAt, find, findIndex, debounceTime, throttleTime, auditTime, audit, sampleTime, sample, ignoreElements, distinct, distinctUntilChanged, distinctUntilKeyChanged, concatWith, mergeWith, combineLatestWith, zipWith, raceWith, withLatestFrom, mergeAll, concatAll, switchAll, exhaustAll, combineLatestAll, zipAll, tap, delay, delayWhen, timeout, takeUntil, finalize, repeat, retry, startWith, endWith, toArray, materialize, dematerialize, observeOn, subscribeOn, timestamp, defaultIfEmpty, every, isEmpty, catchError, retryWhen, share, shareReplay, connect, refCount, pluck, mapTo, switchMapTo, mergeMapTo, concatMapTo, count, max, min, single, throwIfEmpty } from 'rxjs';
+/**
+ * RxJS symbols available in the execution context
+ */
+export declare const rxjsSymbols: {
+    Observable: typeof Observable;
+    Subject: typeof Subject;
+    BehaviorSubject: typeof BehaviorSubject;
+    ReplaySubject: typeof ReplaySubject;
+    AsyncSubject: typeof AsyncSubject;
+    connectable: typeof connectable;
+    of: typeof of;
+    from: typeof from;
+    interval: typeof interval;
+    timer: typeof timer;
+    range: typeof range;
+    generate: typeof generate;
+    concat: typeof concat;
+    merge: typeof merge;
+    combineLatest: typeof combineLatest;
+    zip: typeof zip;
+    forkJoin: typeof forkJoin;
+    race: typeof race;
+    partition: typeof partition;
+    iif: typeof iif;
+    defer: typeof defer;
+    scheduled: typeof scheduled;
+    throwError: typeof throwError;
+    EMPTY: Observable<never>;
+    NEVER: Observable<never>;
+    firstValueFrom: typeof firstValueFrom;
+    lastValueFrom: typeof lastValueFrom;
+    map: typeof map;
+    scan: typeof scan;
+    mergeScan: typeof mergeScan;
+    reduce: typeof reduce;
+    pairwise: typeof pairwise;
+    groupBy: typeof groupBy;
+    mergeMap: typeof mergeMap;
+    switchMap: typeof switchMap;
+    concatMap: typeof concatMap;
+    exhaustMap: typeof exhaustMap;
+    expand: typeof expand;
+    buffer: typeof buffer;
+    bufferTime: typeof bufferTime;
+    bufferCount: typeof bufferCount;
+    bufferWhen: typeof bufferWhen;
+    bufferToggle: typeof bufferToggle;
+    windowTime: typeof windowTime;
+    window: typeof windowOp;
+    windowCount: typeof windowCount;
+    windowToggle: typeof windowToggle;
+    windowWhen: typeof windowWhen;
+    filter: typeof filter;
+    take: typeof take;
+    takeLast: typeof takeLast;
+    takeWhile: typeof takeWhile;
+    skip: typeof skip;
+    skipLast: typeof skipLast;
+    skipWhile: typeof skipWhile;
+    skipUntil: typeof skipUntil;
+    first: typeof first;
+    last: typeof last;
+    elementAt: typeof elementAt;
+    find: typeof find;
+    findIndex: typeof findIndex;
+    debounceTime: typeof debounceTime;
+    throttleTime: typeof throttleTime;
+    auditTime: typeof auditTime;
+    audit: typeof audit;
+    sampleTime: typeof sampleTime;
+    sample: typeof sample;
+    ignoreElements: typeof ignoreElements;
+    distinct: typeof distinct;
+    distinctUntilChanged: typeof distinctUntilChanged;
+    distinctUntilKeyChanged: typeof distinctUntilKeyChanged;
+    concatWith: typeof concatWith;
+    mergeWith: typeof mergeWith;
+    combineLatestWith: typeof combineLatestWith;
+    zipWith: typeof zipWith;
+    raceWith: typeof raceWith;
+    withLatestFrom: typeof withLatestFrom;
+    mergeAll: typeof mergeAll;
+    concatAll: typeof concatAll;
+    switchAll: typeof switchAll;
+    exhaustAll: typeof exhaustAll;
+    combineLatestAll: typeof combineLatestAll;
+    zipAll: typeof zipAll;
+    tap: typeof tap;
+    delay: typeof delay;
+    delayWhen: typeof delayWhen;
+    timeout: typeof timeout;
+    takeUntil: typeof takeUntil;
+    finalize: typeof finalize;
+    repeat: typeof repeat;
+    retry: typeof retry;
+    startWith: typeof startWith;
+    endWith: typeof endWith;
+    toArray: typeof toArray;
+    materialize: typeof materialize;
+    dematerialize: typeof dematerialize;
+    observeOn: typeof observeOn;
+    subscribeOn: typeof subscribeOn;
+    timestamp: typeof timestamp;
+    defaultIfEmpty: typeof defaultIfEmpty;
+    every: typeof every;
+    isEmpty: typeof isEmpty;
+    catchError: typeof catchError;
+    retryWhen: typeof retryWhen;
+    share: typeof share;
+    shareReplay: typeof shareReplay;
+    connect: typeof connect;
+    refCount: typeof refCount;
+    pluck: typeof pluck;
+    mapTo: typeof mapTo;
+    switchMapTo: typeof switchMapTo;
+    mergeMapTo: typeof mergeMapTo;
+    concatMapTo: typeof concatMapTo;
+    count: typeof count;
+    max: typeof max;
+    min: typeof min;
+    single: typeof single;
+    throwIfEmpty: typeof throwIfEmpty;
+};
+/**
+ * Safe globals for the execution context
+ * These are the only non-RxJS APIs available in user code
+ */
+export declare const safeGlobals: {
+    console: {
+        log: (..._args: unknown[]) => void;
+        error: (..._args: unknown[]) => void;
+        warn: (..._args: unknown[]) => void;
+    };
+    setTimeout: typeof setTimeout;
+    clearTimeout: typeof clearTimeout;
+    Date: DateConstructor;
+    Math: Math;
+    JSON: JSON;
+    Array: ArrayConstructor;
+    Object: ObjectConstructor;
+    String: StringConstructor;
+    Number: NumberConstructor;
+    Boolean: BooleanConstructor;
+    Promise: PromiseConstructor;
+};
+/**
+ * Dangerous globals that must be explicitly undefined
+ */
+export declare const blockedGlobals: {
+    process: undefined;
+    require: undefined;
+    module: undefined;
+    exports: undefined;
+    __dirname: undefined;
+    __filename: undefined;
+    global: undefined;
+    globalThis: undefined;
+};
+/**
+ * Creates the complete execution context for user code
+ */
+export declare function createExecutionContext(): Record<string, unknown>;
+export { Observable, EMPTY } from 'rxjs';
+//# sourceMappingURL=rxjs-context.d.ts.map

package/dist/data/rxjs-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rxjs-context.d.ts","sourceRoot":"","sources":["../../src/data/rxjs-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAEL,UAAU,EACV,OAAO,EACP,eAAe,EACf,aAAa,EACb,YAAY,EACZ,WAAW,EAEX,EAAE,EACF,IAAI,EACJ,QAAQ,EACR,KAAK,EACL,KAAK,EACL,QAAQ,EACR,MAAM,EACN,KAAK,EACL,aAAa,EACb,GAAG,EACH,QAAQ,EACR,IAAI,EACJ,SAAS,EACT,GAAG,EACH,KAAK,EACL,SAAS,EACT,UAAU,EAGV,cAAc,EACd,aAAa,EAEb,GAAG,EACH,IAAI,EACJ,SAAS,EACT,MAAM,EACN,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,EACV,MAAM,EACN,MAAM,EACN,UAAU,EACV,WAAW,EACX,UAAU,EACV,YAAY,EACZ,UAAU,EACV,MAAM,IAAI,QAAQ,EAClB,WAAW,EACX,YAAY,EACZ,UAAU,EAEV,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,SAAS,EACT,KAAK,EACL,IAAI,EACJ,SAAS,EACT,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,KAAK,EACL,UAAU,EACV,MAAM,EACN,cAAc,EACd,QAAQ,EACR,oBAAoB,EACpB,uBAAuB,EAEvB,UAAU,EACV,SAAS,EACT,iBAAiB,EACjB,OAAO,EACP,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,MAAM,EAEN,GAAG,EACH,KAAK,EACL,SAAS,EACT,OAAO,EACP,SAAS,EACT,QAAQ,EACR,MAAM,EACN,KAAK,EACL,SAAS,EACT,OAAO,EACP,OAAO,EACP,WAAW,EACX,aAAa,EACb,SAAS,EACT,WAAW,EACX,SAAS,EAET,cAAc,EACd,KAAK,EACL,OAAO,EAEP,UAAU,EACV,SAAS,EAET,KAAK,EACL,WAAW,EACX,OAAO,EACP,QAAQ,EAER,KAAK,EACL,KAAK,EACL,WAAW,EACX,UAAU,EACV,WAAW,EAEX,KAAK,EACL,GAAG,EACH,GAAG,EACH,MAAM,EACN,YAAY,EACb,MAAM,MAAM,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkIvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW;;wBAEJ,OAAO,EAAE;0BACP,OAAO,EAAE;yBACV,OAAO,EAAE;;;;;;;;;;;;;CAa7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;CAS1B,CAAC;AAEF;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMhE;AAGD,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC"}