@memberjunction/react-runtime 2.70.0

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @memberjunction/react-runtime@2.70.0 build
+> tsc
+

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+# @memberjunction/react-runtime
+
+## 2.70.0

package/README.md

@@ -0,0 +1,224 @@
+# @memberjunction/react-runtime
+
+Platform-agnostic React component runtime for MemberJunction. This package provides core compilation, registry, and execution capabilities for React components in any JavaScript environment.
+
+## Overview
+
+The React Runtime package enables dynamic compilation and execution of React components from source code. It works in both browser and Node.js environments, making it suitable for client-side rendering and server-side testing.
+
+## Features
+
+- **Dynamic Compilation**: Transform JSX and React code at runtime using Babel
+- **Component Registry**: Manage compiled components with namespace support
+- **Dependency Resolution**: Handle component hierarchies and dependencies
+- **Error Boundaries**: Comprehensive error handling for React components
+- **Platform Agnostic**: Works in any JavaScript environment
+- **Type Safe**: Full TypeScript support with strict typing
+
+## Installation
+
+```bash
+npm install @memberjunction/react-runtime
+```
+
+## Basic Usage
+
+### Creating a Runtime Instance
+
+```typescript
+import { createReactRuntime } from '@memberjunction/react-runtime';
+import * as Babel from '@babel/standalone';
+
+// Create runtime with Babel instance
+const runtime = createReactRuntime(Babel);
+```
+
+### Compiling a Component
+
+```typescript
+const componentCode = `
+  function MyComponent({ data, userState, callbacks }) {
+    return (
+      <div>
+        <h1>Hello, {data.name}!</h1>
+        <button onClick={() => callbacks.RefreshData()}>
+          Refresh
+        </button>
+      </div>
+    );
+  }
+`;
+
+// Compile the component
+const result = await runtime.compiler.compile({
+  componentName: 'MyComponent',
+  componentCode: componentCode
+});
+
+if (result.success) {
+  // Register the compiled component
+  runtime.registry.register(
+    'MyComponent',
+    result.component.component,
+    'MyNamespace',
+    'v1'
+  );
+}
+```
+
+### Using the Component
+
+```typescript
+// Get React context (provided by your environment)
+const React = window.React; // or require('react')
+const ReactDOM = window.ReactDOM; // or require('react-dom')
+
+// Create runtime context
+const context = { React, ReactDOM };
+
+// Get the compiled component
+const MyComponent = runtime.registry.get('MyComponent', 'MyNamespace');
+
+// Execute the component factory
+const { component } = MyComponent(context);
+
+// Render with props
+const props = {
+  data: { name: 'World' },
+  userState: {},
+  callbacks: {
+    RefreshData: () => console.log('Refresh clicked!')
+  }
+};
+
+React.createElement(component, props);
+```
+
+## Advanced Features
+
+### Component Hierarchies
+
+```typescript
+const parentSpec = {
+  componentName: 'ParentComponent',
+  componentCode: '...',
+  childComponents: [
+    {
+      componentName: 'ChildComponent1',
+      componentCode: '...'
+    },
+    {
+      componentName: 'ChildComponent2',
+      componentCode: '...'
+    }
+  ]
+};
+
+// Resolve all components in hierarchy
+const components = runtime.resolver.resolveComponents(parentSpec);
+```
+
+### Error Boundaries
+
+```typescript
+import { createErrorBoundary } from '@memberjunction/react-runtime';
+
+const ErrorBoundary = createErrorBoundary(React, {
+  onError: (error, errorInfo) => {
+    console.error('Component error:', error);
+  },
+  fallback: <div>Something went wrong</div>,
+  recovery: 'retry'
+});
+
+// Wrap your component
+<ErrorBoundary>
+  <YourComponent />
+</ErrorBoundary>
+```
+
+### Component Registry Management
+
+```typescript
+// Check if component exists
+if (runtime.registry.has('MyComponent')) {
+  // Get component with reference counting
+  const component = runtime.registry.get('MyComponent');
+  
+  // Release when done
+  runtime.registry.release('MyComponent');
+}
+
+// Get registry statistics
+const stats = runtime.registry.getStats();
+console.log(`Total components: ${stats.totalComponents}`);
+
+// Clean up unused components
+const removed = runtime.registry.cleanup();
+console.log(`Removed ${removed} unused components`);
+```
+
+## Configuration
+
+### Compiler Configuration
+
+```typescript
+const runtime = createReactRuntime(Babel, {
+  compiler: {
+    babel: {
+      presets: ['react'],
+      plugins: ['transform-optional-chaining']
+    },
+    minify: true,
+    sourceMaps: true,
+    cache: true,
+    maxCacheSize: 200
+  }
+});
+```
+
+### Registry Configuration
+
+```typescript
+const runtime = createReactRuntime(Babel, {
+  registry: {
+    maxComponents: 500,
+    cleanupInterval: 30000, // 30 seconds
+    useLRU: true,
+    enableNamespaces: true
+  }
+});
+```
+
+## API Reference
+
+### Types
+
+- `CompileOptions` - Options for compiling components
+- `ComponentProps` - Standard props passed to components
+- `ComponentCallbacks` - Callback functions available to components
+- `RegistryEntry` - Registry entry with metadata
+
+### Classes
+
+- `ComponentCompiler` - Compiles React components from source
+- `ComponentRegistry` - Manages compiled components
+- `ComponentResolver` - Resolves component dependencies
+
+### Utilities
+
+- `createErrorBoundary()` - Creates error boundary components
+- `buildComponentProps()` - Builds standardized component props
+- `wrapComponent()` - Wraps components with additional functionality
+
+## Best Practices
+
+1. **Always Set Babel Instance**: Call `setBabelInstance()` before compiling
+2. **Use Namespaces**: Organize components with namespaces
+3. **Handle Errors**: Always check compilation results for errors
+4. **Clean Up**: Use registry cleanup for long-running applications
+5. **Type Safety**: Leverage TypeScript types for better development experience
+
+## License
+
+See the main MemberJunction LICENSE file in the repository root.

package/dist/compiler/babel-config.d.ts

@@ -0,0 +1,40 @@
+export declare const DEFAULT_PRESETS: string[];
+export declare const DEFAULT_PLUGINS: string[];
+export declare const PRODUCTION_CONFIG: {
+    presets: string[];
+    plugins: string[];
+    minified: boolean;
+    comments: boolean;
+};
+export declare const DEVELOPMENT_CONFIG: {
+    presets: string[];
+    plugins: string[];
+    sourceMaps: string;
+    minified: boolean;
+    comments: boolean;
+};
+export declare function getBabelConfig(production?: boolean): {
+    presets: string[];
+    plugins: string[];
+    minified: boolean;
+    comments: boolean;
+};
+export declare function validateBabelPresets(babel: any): boolean;
+export declare const JSX_PRAGMAS: {
+    classic: {
+        pragma: string;
+        pragmaFrag: string;
+    };
+    automatic: {
+        runtime: string;
+        importSource: string;
+    };
+};
+export declare function getJSXConfig(reactVersion?: string): {
+    pragma: string;
+    pragmaFrag: string;
+} | {
+    runtime: string;
+    importSource: string;
+};
+//# sourceMappingURL=babel-config.d.ts.map

package/dist/compiler/babel-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-config.d.ts","sourceRoot":"","sources":["../../src/compiler/babel-config.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,eAAe,UAE3B,CAAC;AAKF,eAAO,MAAM,eAAe,EAAE,MAAM,EAGnC,CAAC;AAKF,eAAO,MAAM,iBAAiB;;;;;CAQ7B,CAAC;AAKF,eAAO,MAAM,kBAAkB;;;;;;CAS9B,CAAC;AAOF,wBAAgB,cAAc,CAAC,UAAU,GAAE,OAAe;;;;;EAEzD;AAOD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAOxD;AAKD,eAAO,MAAM,WAAW;;;;;;;;;CASvB,CAAC;AAOF,wBAAgB,YAAY,CAAC,YAAY,CAAC,EAAE,MAAM;;;;;;EAMjD"}

package/dist/compiler/babel-config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSXConfig = exports.JSX_PRAGMAS = exports.validateBabelPresets = exports.getBabelConfig = exports.DEVELOPMENT_CONFIG = exports.PRODUCTION_CONFIG = exports.DEFAULT_PLUGINS = exports.DEFAULT_PRESETS = void 0;
+exports.DEFAULT_PRESETS = [
+    'react',
+];
+exports.DEFAULT_PLUGINS = [];
+exports.PRODUCTION_CONFIG = {
+    presets: exports.DEFAULT_PRESETS,
+    plugins: [
+        ...exports.DEFAULT_PLUGINS,
+    ],
+    minified: true,
+    comments: false
+};
+exports.DEVELOPMENT_CONFIG = {
+    presets: exports.DEFAULT_PRESETS,
+    plugins: [
+        ...exports.DEFAULT_PLUGINS,
+    ],
+    sourceMaps: 'inline',
+    minified: false,
+    comments: true
+};
+function getBabelConfig(production = false) {
+    return production ? exports.PRODUCTION_CONFIG : exports.DEVELOPMENT_CONFIG;
+}
+exports.getBabelConfig = getBabelConfig;
+function validateBabelPresets(babel) {
+    if (!babel || !babel.availablePresets) {
+        return false;
+    }
+    return 'react' in babel.availablePresets;
+}
+exports.validateBabelPresets = validateBabelPresets;
+exports.JSX_PRAGMAS = {
+    classic: {
+        pragma: 'React.createElement',
+        pragmaFrag: 'React.Fragment'
+    },
+    automatic: {
+        runtime: 'automatic',
+        importSource: 'react'
+    }
+};
+function getJSXConfig(reactVersion) {
+    if (reactVersion && parseInt(reactVersion.split('.')[0]) >= 17) {
+        return exports.JSX_PRAGMAS.automatic;
+    }
+    return exports.JSX_PRAGMAS.classic;
+}
+exports.getJSXConfig = getJSXConfig;

package/dist/compiler/component-compiler.d.ts

@@ -0,0 +1,22 @@
+import { CompileOptions, CompilationResult, CompilerConfig } from '../types';
+export declare class ComponentCompiler {
+    private config;
+    private compilationCache;
+    private babelInstance;
+    constructor(config?: Partial<CompilerConfig>);
+    setBabelInstance(babel: any): void;
+    compile(options: CompileOptions): Promise<CompilationResult>;
+    private transpileComponent;
+    private wrapComponentCode;
+    private createComponentFactory;
+    private createStateUpdaterUtility;
+    private validateCompileOptions;
+    private generateComponentId;
+    private getCachedComponent;
+    private cacheComponent;
+    private createCompilationError;
+    clearCache(): void;
+    getCacheSize(): number;
+    updateConfig(config: Partial<CompilerConfig>): void;
+}
+//# sourceMappingURL=component-compiler.d.ts.map

package/dist/compiler/component-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-compiler.d.ts","sourceRoot":"","sources":["../../src/compiler/component-compiler.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,cAAc,EAEd,iBAAiB,EACjB,cAAc,EAGf,MAAM,UAAU,CAAC;AAoBlB,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,gBAAgB,CAAiC;IACzD,OAAO,CAAC,aAAa,CAAM;gBAMf,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAS5C,gBAAgB,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI;IAS5B,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAqElE,OAAO,CAAC,kBAAkB;IAgC1B,OAAO,CAAC,iBAAiB;IAgCzB,OAAO,CAAC,sBAAsB;IAmD9B,OAAO,CAAC,yBAAyB;IAwBjC,OAAO,CAAC,sBAAsB;IAwB9B,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,cAAc;IAiBtB,OAAO,CAAC,sBAAsB;IAa9B,UAAU,IAAI,IAAI;IAQlB,YAAY,IAAI,MAAM;IAQtB,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI;CAGpD"}

package/dist/compiler/component-compiler.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentCompiler = void 0;
+const DEFAULT_COMPILER_CONFIG = {
+    babel: {
+        presets: ['react'],
+        plugins: []
+    },
+    minify: false,
+    sourceMaps: false,
+    cache: true,
+    maxCacheSize: 100
+};
+class ComponentCompiler {
+    constructor(config) {
+        this.config = { ...DEFAULT_COMPILER_CONFIG, ...config };
+        this.compilationCache = new Map();
+    }
+    setBabelInstance(babel) {
+        this.babelInstance = babel;
+    }
+    async compile(options) {
+        const startTime = Date.now();
+        try {
+            if (this.config.cache) {
+                const cached = this.getCachedComponent(options.componentName);
+                if (cached) {
+                    return {
+                        success: true,
+                        component: cached,
+                        duration: Date.now() - startTime
+                    };
+                }
+            }
+            this.validateCompileOptions(options);
+            const transpiledCode = this.transpileComponent(options.componentCode, options.componentName, options);
+            const componentFactory = this.createComponentFactory(transpiledCode, options.componentName);
+            const compiledComponent = {
+                component: componentFactory,
+                id: this.generateComponentId(options.componentName),
+                name: options.componentName,
+                compiledAt: new Date(),
+                warnings: []
+            };
+            if (this.config.cache) {
+                this.cacheComponent(compiledComponent);
+            }
+            return {
+                success: true,
+                component: compiledComponent,
+                duration: Date.now() - startTime,
+                size: transpiledCode.length
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: this.createCompilationError(error, options.componentName),
+                duration: Date.now() - startTime
+            };
+        }
+    }
+    transpileComponent(code, componentName, options) {
+        if (!this.babelInstance) {
+            throw new Error('Babel instance not set. Call setBabelInstance() first.');
+        }
+        const wrappedCode = this.wrapComponentCode(code, componentName);
+        try {
+            const result = this.babelInstance.transform(wrappedCode, {
+                presets: options.babelPresets || this.config.babel.presets,
+                plugins: options.babelPlugins || this.config.babel.plugins,
+                filename: `${componentName}.jsx`,
+                sourceMaps: this.config.sourceMaps,
+                minified: this.config.minify
+            });
+            return result.code;
+        }
+        catch (error) {
+            throw new Error(`Transpilation failed: ${error.message}`);
+        }
+    }
+    wrapComponentCode(componentCode, componentName) {
+        return `
+      function createComponent(React, ReactDOM, useState, useEffect, useCallback, createStateUpdater, libraries, styles, console) {
+        ${componentCode}
+        
+        // Ensure the component exists
+        if (typeof ${componentName} === 'undefined') {
+          throw new Error('Component "${componentName}" is not defined in the provided code');
+        }
+        
+        // Return the component with utilities
+        return {
+          component: ${componentName},
+          print: function() { 
+            if (typeof window !== 'undefined' && window.print) {
+              window.print(); 
+            }
+          },
+          refresh: function(data) { 
+            // Refresh functionality is handled by the host environment
+          }
+        };
+      }
+    `;
+    }
+    createComponentFactory(transpiledCode, componentName) {
+        try {
+            const factoryCreator = new Function('React', 'ReactDOM', 'useState', 'useEffect', 'useCallback', 'createStateUpdater', 'libraries', 'styles', 'console', `${transpiledCode}; return createComponent;`);
+            return (context, styles = {}) => {
+                const { React, ReactDOM, libraries = {} } = context;
+                const createStateUpdater = this.createStateUpdaterUtility();
+                const createComponentFn = factoryCreator(React, ReactDOM, React.useState, React.useEffect, React.useCallback, createStateUpdater, libraries, styles, console);
+                return createComponentFn(React, ReactDOM, React.useState, React.useEffect, React.useCallback, createStateUpdater, libraries, styles, console);
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to create component factory: ${error.message}`);
+        }
+    }
+    createStateUpdaterUtility() {
+        return (statePath, parentStateUpdater) => {
+            return (componentStateUpdate) => {
+                if (!statePath) {
+                    parentStateUpdater(componentStateUpdate);
+                }
+                else {
+                    const pathParts = statePath.split('.');
+                    const componentKey = pathParts[pathParts.length - 1];
+                    parentStateUpdater({
+                        [componentKey]: componentStateUpdate
+                    });
+                }
+            };
+        };
+    }
+    validateCompileOptions(options) {
+        if (!options.componentName) {
+            throw new Error('Component name is required');
+        }
+        if (!options.componentCode) {
+            throw new Error('Component code is required');
+        }
+        if (typeof options.componentCode !== 'string') {
+            throw new Error('Component code must be a string');
+        }
+        if (!options.componentCode.includes(options.componentName)) {
+            throw new Error(`Component code must define a component named "${options.componentName}"`);
+        }
+    }
+    generateComponentId(componentName) {
+        return `${componentName}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    getCachedComponent(componentName) {
+        for (const [key, component] of this.compilationCache) {
+            if (component.name === componentName) {
+                return component;
+            }
+        }
+        return undefined;
+    }
+    cacheComponent(component) {
+        if (this.compilationCache.size >= this.config.maxCacheSize) {
+            const firstKey = this.compilationCache.keys().next().value;
+            this.compilationCache.delete(firstKey);
+        }
+        this.compilationCache.set(component.id, component);
+    }
+    createCompilationError(error, componentName) {
+        return {
+            message: error.message || 'Unknown compilation error',
+            stack: error.stack,
+            componentName,
+            phase: 'compilation',
+            details: error
+        };
+    }
+    clearCache() {
+        this.compilationCache.clear();
+    }
+    getCacheSize() {
+        return this.compilationCache.size;
+    }
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+exports.ComponentCompiler = ComponentCompiler;

package/dist/compiler/index.d.ts

@@ -0,0 +1,3 @@
+export { ComponentCompiler } from './component-compiler';
+export { DEFAULT_PRESETS, DEFAULT_PLUGINS, PRODUCTION_CONFIG, DEVELOPMENT_CONFIG, getBabelConfig, validateBabelPresets, getJSXConfig } from './babel-config';
+//# sourceMappingURL=index.d.ts.map

package/dist/compiler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compiler/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EACL,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACb,MAAM,gBAAgB,CAAC"}

package/dist/compiler/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSXConfig = exports.validateBabelPresets = exports.getBabelConfig = exports.DEVELOPMENT_CONFIG = exports.PRODUCTION_CONFIG = exports.DEFAULT_PLUGINS = exports.DEFAULT_PRESETS = exports.ComponentCompiler = void 0;
+var component_compiler_1 = require("./component-compiler");
+Object.defineProperty(exports, "ComponentCompiler", { enumerable: true, get: function () { return component_compiler_1.ComponentCompiler; } });
+var babel_config_1 = require("./babel-config");
+Object.defineProperty(exports, "DEFAULT_PRESETS", { enumerable: true, get: function () { return babel_config_1.DEFAULT_PRESETS; } });
+Object.defineProperty(exports, "DEFAULT_PLUGINS", { enumerable: true, get: function () { return babel_config_1.DEFAULT_PLUGINS; } });
+Object.defineProperty(exports, "PRODUCTION_CONFIG", { enumerable: true, get: function () { return babel_config_1.PRODUCTION_CONFIG; } });
+Object.defineProperty(exports, "DEVELOPMENT_CONFIG", { enumerable: true, get: function () { return babel_config_1.DEVELOPMENT_CONFIG; } });
+Object.defineProperty(exports, "getBabelConfig", { enumerable: true, get: function () { return babel_config_1.getBabelConfig; } });
+Object.defineProperty(exports, "validateBabelPresets", { enumerable: true, get: function () { return babel_config_1.validateBabelPresets; } });
+Object.defineProperty(exports, "getJSXConfig", { enumerable: true, get: function () { return babel_config_1.getJSXConfig; } });

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { ComponentCompiler } from './compiler';
+import { ComponentRegistry } from './registry';
+import { ComponentResolver } from './registry';
+export * from './types';
+export { ComponentCompiler } from './compiler';
+export { DEFAULT_PRESETS, DEFAULT_PLUGINS, PRODUCTION_CONFIG, DEVELOPMENT_CONFIG, getBabelConfig, validateBabelPresets, getJSXConfig } from './compiler';
+export { ComponentRegistry } from './registry';
+export { ComponentResolver, ComponentSpec, ResolvedComponents } from './registry';
+export { createErrorBoundary, withErrorBoundary, formatComponentError, createErrorLogger } from './runtime';
+export { wrapComponent, memoizeComponent, lazyComponent, injectProps, conditionalComponent, withErrorHandler, portalComponent, WrapperOptions } from './runtime';
+export { buildComponentProps, normalizeCallbacks, normalizeStyles, validateComponentProps, mergeProps, createPropsTransformer, wrapCallbacksWithLogging, extractPropPaths, PropBuilderOptions } from './runtime';
+export { ComponentHierarchyRegistrar, registerComponentHierarchy, validateComponentSpec, flattenComponentHierarchy, countComponentsInHierarchy, HierarchyRegistrationResult, ComponentRegistrationError, HierarchyRegistrationOptions } from './runtime';
+export declare const VERSION = "2.69.1";
+export declare const DEFAULT_CONFIGS: {
+    compiler: {
+        babel: {
+            presets: string[];
+            plugins: never[];
+        };
+        minify: boolean;
+        sourceMaps: boolean;
+        cache: boolean;
+        maxCacheSize: number;
+    };
+    registry: {
+        maxComponents: number;
+        cleanupInterval: number;
+        useLRU: boolean;
+        enableNamespaces: boolean;
+    };
+};
+export declare function createReactRuntime(babelInstance: any, config?: {
+    compiler?: Partial<import('./types').CompilerConfig>;
+    registry?: Partial<import('./types').RegistryConfig>;
+}): {
+    compiler: ComponentCompiler;
+    registry: ComponentRegistry;
+    resolver: ComponentResolver;
+    version: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAG/C,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EACL,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACb,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,cAAc,EACf,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,UAAU,EACV,sBAAsB,EACtB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,EAC1B,qBAAqB,EACrB,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,WAAW,CAAC;AAGnB,eAAO,MAAM,OAAO,WAAW,CAAC;AAGhC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAiB3B,CAAC;AAQF,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,GAAG,EAClB,MAAM,CAAC,EAAE;IACP,QAAQ,CAAC,EAAE,OAAO,CAAC,OAAO,SAAS,EAAE,cAAc,CAAC,CAAC;IACrD,QAAQ,CAAC,EAAE,OAAO,CAAC,OAAO,SAAS,EAAE,cAAc,CAAC,CAAC;CACtD;;;;;EAcF"}