@bluealba/pae-feature-flags 1.0.0-feature-initial-feature-flags-poc-1233

package/README.md

@@ -0,0 +1,239 @@
+# @bluealba/pae-feature-flags
+
+Feature flags client library for Blue Alba Platform.
+
+## Installation
+
+```bash
+npm install @bluealba/pae-feature-flags
+```
+
+## NestJS Usage
+
+### 1. Import the Module
+
+```typescript
+import { Module } from '@nestjs/common';
+import { FeatureFlagsModule } from '@bluealba/pae-feature-flags';
+
+@Module({
+  imports: [
+    FeatureFlagsModule.forRoot('http://gateway:3000'),
+    // Or with full configuration
+    FeatureFlagsModule.forRoot({
+      gatewayUrl: 'http://gateway:3000',
+      timeout: 5000,
+      maxRedirects: 5,
+    }),
+  ],
+})
+export class MyServiceModule {}
+```
+
+### 2. Use the Client
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { FeatureFlagsClient } from '@bluealba/pae-feature-flags';
+
+@Injectable()
+export class MyService {
+  constructor(private readonly featureFlagsClient: FeatureFlagsClient) {}
+
+  async doSomething() {
+    // Check if a feature is enabled
+    const isEnabled = await this.featureFlagsClient.isEnabled('my-feature');
+    
+    if (isEnabled) {
+      // New implementation
+    } else {
+      // Old implementation
+    }
+    
+    // Get variant for A/B testing
+    const variant = await this.featureFlagsClient.getVariant('ab-test', {
+      userId: '123',
+      tenantId: 'tenant-1',
+    });
+    
+    if (variant?.name === 'variant-a') {
+      // Variant A logic
+    } else if (variant?.name === 'variant-b') {
+      // Variant B logic
+    }
+    
+    // Evaluate multiple flags at once (more efficient)
+    const results = await this.featureFlagsClient.evaluateFlags(
+      ['feature-a', 'feature-b', 'ab-test'],
+      { userId: '123' }
+    );
+    
+    const featureAEnabled = results.get('feature-a')?.enabled ?? false;
+  }
+}
+```
+
+## React Usage
+
+### 1. Setup the Provider
+
+Wrap your application with the `FeatureFlagsProvider`:
+
+```tsx
+import { FeatureFlagsProvider } from '@bluealba/pae-feature-flags';
+
+function App() {
+  return (
+    <FeatureFlagsProvider
+      gatewayUrl="/api"
+      prefetchFlags={['new-ui', 'beta-feature']}
+      refreshInterval={60000}
+    >
+      <YourApp />
+    </FeatureFlagsProvider>
+  );
+}
+```
+
+#### Provider Props
+
+- `gatewayUrl` (string, optional): Base URL for the gateway API. Default: `''`
+- `prefetchFlags` (string[], optional): Array of flag names to prefetch on mount
+- `refreshInterval` (number, optional): Interval in milliseconds for automatic refresh
+- `children` (ReactNode): Child components
+
+### 2. Use Feature Flags in Components
+
+#### Simple Boolean Check with `useFeatureFlag`
+
+```tsx
+import { useFeatureFlag } from '@bluealba/pae-feature-flags';
+
+function MyComponent() {
+  const isNewUIEnabled = useFeatureFlag('new-ui', false);
+
+  return isNewUIEnabled ? <NewUI /> : <OldUI />;
+}
+```
+
+#### Conditional Rendering with `FeatureFlagGuard`
+
+```tsx
+import { FeatureFlagGuard } from '@bluealba/pae-feature-flags';
+
+function MyComponent() {
+  return (
+    <>
+      {/* Show feature if enabled */}
+      <FeatureFlagGuard flag="beta-feature">
+        <BetaFeature />
+      </FeatureFlagGuard>
+
+      {/* Show feature if enabled, fallback if disabled */}
+      <FeatureFlagGuard flag="new-ui" fallback={<OldUI />}>
+        <NewUI />
+      </FeatureFlagGuard>
+
+      {/* Inverted logic - show if disabled */}
+      <FeatureFlagGuard flag="maintenance-mode" invert>
+        <MainApp />
+      </FeatureFlagGuard>
+    </>
+  );
+}
+```
+
+#### Multivariant Flags with `useVariant`
+
+For A/B testing and feature variants:
+
+```tsx
+import { useVariant } from '@bluealba/pae-feature-flags';
+
+function CheckoutFlow() {
+  const { variant, payload, isLoading } = useVariant('checkout-flow');
+
+  if (isLoading) {
+    return <Spinner />;
+  }
+
+  if (variant === 'new-checkout') {
+    return <NewCheckout config={payload} />;
+  }
+
+  if (variant === 'express-checkout') {
+    return <ExpressCheckout config={payload} />;
+  }
+
+  return <DefaultCheckout />;
+}
+```
+
+#### Access Full Context with `useFeatureFlags`
+
+```tsx
+import { useFeatureFlags } from '@bluealba/pae-feature-flags';
+
+function FlagsDebugPanel() {
+  const { flags, variants, isLoading, error, refresh } = useFeatureFlags();
+
+  const handleRefresh = async () => {
+    await refresh();
+  };
+
+  return (
+    <div>
+      <button onClick={handleRefresh} disabled={isLoading}>
+        Refresh Flags
+      </button>
+      {error && <div>Error: {error.message}</div>}
+      <div>Total flags loaded: {flags.size}</div>
+      <ul>
+        {Array.from(flags.entries()).map(([name, enabled]) => (
+          <li key={name}>
+            {name}: {enabled ? 'enabled' : 'disabled'}
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+```
+
+### React Best Practices
+
+1. **Prefetch Common Flags**: Add frequently used flags to `prefetchFlags` for better performance
+2. **Use FeatureFlagGuard**: Cleaner than inline conditions for simple toggles
+3. **Handle Loading States**: Always handle `isLoading` when using `useVariant`
+4. **Provide Defaults**: Always provide default values to `useFeatureFlag`
+5. **Minimize Refresh**: Don't set refresh intervals too low to avoid network overhead
+
+## API Reference
+
+### FeatureFlagsClient
+
+#### `isEnabled(flagName, defaultValue?, context?): Promise<boolean>`
+
+Evaluates if a feature flag is enabled.
+
+- `flagName`: Name of the feature flag
+- `defaultValue`: Default value if evaluation fails (default: false)
+- `context`: Optional evaluation context (userId, tenantId, customProperties)
+
+#### `getVariant(flagName, context?): Promise<{name: string, payload: any} | null>`
+
+Gets the variant for a multivariant feature flag.
+
+- `flagName`: Name of the feature flag
+- `context`: Optional evaluation context
+
+#### `evaluateFlags(flagNames, context?): Promise<Map<string, FlagEvaluationResult>>`
+
+Evaluates multiple feature flags in a single request.
+
+- `flagNames`: Array of feature flag names
+- `context`: Optional evaluation context
+
+## License
+
+PolyForm-Noncommercial-1.0.0

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Core types and interfaces for feature flags
+ */
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,SAAS,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Core types and interfaces for feature flags
+ */
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,0CAAwB"}

package/dist/core/types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Core types for feature flags system
+ * These types are shared across React and NestJS implementations
+ */
+/**
+ * Type of feature flag
+ */
+export declare enum FeatureFlagType {
+    BOOLEAN = "BOOLEAN",
+    MULTIVARIANT = "MULTIVARIANT"
+}
+/**
+ * Variant configuration for multivariant flags
+ */
+export interface FeatureFlagVariant {
+    name: string;
+    weight?: number;
+    payload?: any;
+    stickiness?: string;
+}
+/**
+ * Feature flag evaluation context
+ * Used to determine flag values based on user, tenant, or custom properties
+ */
+export interface FeatureFlagContext {
+    userId?: string;
+    tenantId?: string;
+    sessionId?: string;
+    customProperties?: Record<string, any>;
+}
+/**
+ * Result of a feature flag evaluation
+ */
+export interface FlagEvaluationResult {
+    enabled: boolean;
+    variant?: string;
+    payload?: any;
+}
+/**
+ * Bulk evaluation response
+ */
+export interface BulkEvaluationResult {
+    flags: Map<string, FlagEvaluationResult>;
+}
+/**
+ * Feature flag definition
+ */
+export interface FeatureFlag {
+    name: string;
+    type: FeatureFlagType;
+    enabled: boolean;
+    description?: string;
+    variants?: FeatureFlagVariant[];
+}
+/**
+ * Configuration for feature flags client
+ */
+export interface FeatureFlagsConfig {
+    gatewayUrl: string;
+    timeout?: number;
+    retries?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,oBAAY,eAAe;IACzB,OAAO,YAAY;IACnB,YAAY,iBAAiB;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/core/types.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Core types for feature flags system
+ * These types are shared across React and NestJS implementations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagType = void 0;
+/**
+ * Type of feature flag
+ */
+var FeatureFlagType;
+(function (FeatureFlagType) {
+    FeatureFlagType["BOOLEAN"] = "BOOLEAN";
+    FeatureFlagType["MULTIVARIANT"] = "MULTIVARIANT";
+})(FeatureFlagType || (exports.FeatureFlagType = FeatureFlagType = {}));
+//# sourceMappingURL=types.js.map

package/dist/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;GAEG;AACH,IAAY,eAGX;AAHD,WAAY,eAAe;IACzB,sCAAmB,CAAA;IACnB,gDAA6B,CAAA;AAC/B,CAAC,EAHW,eAAe,+BAAf,eAAe,QAG1B"}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @bluealba/pae-feature-flags
+ *
+ * Feature flags client library for Blue Alba Platform
+ *
+ * This library provides both React hooks and NestJS client for consuming
+ * feature flags from the gateway service.
+ *
+ * @example NestJS Usage
+ * ```typescript
+ * import { FeatureFlagsModule, FeatureFlagsClient } from '@bluealba/pae-feature-flags';
+ *
+ * @Module({
+ *   imports: [
+ *     FeatureFlagsModule.forRoot('http://gateway:3000'),
+ *   ],
+ *   providers: [MyService],
+ * })
+ * export class MyServiceModule {}
+ *
+ * @Injectable()
+ * export class MyService {
+ *   constructor(private readonly featureFlagsClient: FeatureFlagsClient) {}
+ *
+ *   async doSomething() {
+ *     const isEnabled = await this.featureFlagsClient.isEnabled('my-feature');
+ *     if (isEnabled) {
+ *       // New implementation
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example React Usage
+ * ```typescript
+ * import { FeatureFlagsProvider, useFeatureFlag } from '@bluealba/pae-feature-flags';
+ *
+ * // In your app root
+ * <FeatureFlagsProvider gatewayUrl="http://gateway:3000">
+ *   <App />
+ * </FeatureFlagsProvider>
+ *
+ * // In a component
+ * function MyComponent() {
+ *   const isEnabled = useFeatureFlag('my-feature');
+ *
+ *   return isEnabled ? <NewFeature /> : <OldFeature />;
+ * }
+ * ```
+ */
+export * from './core';
+export * from './nestjs';
+export * from './react';
+//# 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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAGH,cAAc,QAAQ,CAAC;AAGvB,cAAc,UAAU,CAAC;AAGzB,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * @bluealba/pae-feature-flags
+ *
+ * Feature flags client library for Blue Alba Platform
+ *
+ * This library provides both React hooks and NestJS client for consuming
+ * feature flags from the gateway service.
+ *
+ * @example NestJS Usage
+ * ```typescript
+ * import { FeatureFlagsModule, FeatureFlagsClient } from '@bluealba/pae-feature-flags';
+ *
+ * @Module({
+ *   imports: [
+ *     FeatureFlagsModule.forRoot('http://gateway:3000'),
+ *   ],
+ *   providers: [MyService],
+ * })
+ * export class MyServiceModule {}
+ *
+ * @Injectable()
+ * export class MyService {
+ *   constructor(private readonly featureFlagsClient: FeatureFlagsClient) {}
+ *
+ *   async doSomething() {
+ *     const isEnabled = await this.featureFlagsClient.isEnabled('my-feature');
+ *     if (isEnabled) {
+ *       // New implementation
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example React Usage
+ * ```typescript
+ * import { FeatureFlagsProvider, useFeatureFlag } from '@bluealba/pae-feature-flags';
+ *
+ * // In your app root
+ * <FeatureFlagsProvider gatewayUrl="http://gateway:3000">
+ *   <App />
+ * </FeatureFlagsProvider>
+ *
+ * // In a component
+ * function MyComponent() {
+ *   const isEnabled = useFeatureFlag('my-feature');
+ *
+ *   return isEnabled ? <NewFeature /> : <OldFeature />;
+ * }
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Core types (shared between React and NestJS)
+__exportStar(require("./core"), exports);
+// NestJS exports
+__exportStar(require("./nestjs"), exports);
+// React exports
+__exportStar(require("./react"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;;;;;;;;;;;;;;;;AAEH,+CAA+C;AAC/C,yCAAuB;AAEvB,iBAAiB;AACjB,2CAAyB;AAEzB,gBAAgB;AAChB,0CAAwB"}

package/dist/nestjs/FeatureFlagsClient.d.ts

@@ -0,0 +1,99 @@
+import { HttpService } from '@nestjs/axios';
+import { FeatureFlagContext, FlagEvaluationResult } from '../core/types';
+/**
+ * Client for consuming feature flags from the gateway service
+ *
+ * This service provides methods to evaluate feature flags by calling
+ * the gateway API endpoints. It handles errors gracefully by returning
+ * default values when the API is unavailable or returns errors.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class MyService {
+ *   constructor(private readonly featureFlagsClient: FeatureFlagsClient) {}
+ *
+ *   async doSomething() {
+ *     const isEnabled = await this.featureFlagsClient.isEnabled('my-feature');
+ *     if (isEnabled) {
+ *       // New implementation
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class FeatureFlagsClient {
+    private readonly gatewayUrl;
+    private readonly httpService;
+    private readonly logger;
+    constructor(gatewayUrl: string, httpService: HttpService);
+    /**
+     * Evaluates if a feature flag is enabled
+     *
+     * @param flagName - The name of the feature flag to evaluate
+     * @param defaultValue - The default value to return if evaluation fails (default: false)
+     * @param context - Optional evaluation context (user, tenant, custom properties)
+     * @returns Promise resolving to true if flag is enabled, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isEnabled = await client.isEnabled('new-dashboard', false, {
+     *   userId: '123',
+     *   tenantId: 'tenant-1'
+     * });
+     * ```
+     */
+    isEnabled(flagName: string, defaultValue?: boolean, context?: FeatureFlagContext): Promise<boolean>;
+    /**
+     * Gets the variant for a multivariant feature flag
+     *
+     * @param flagName - The name of the feature flag
+     * @param context - Optional evaluation context
+     * @returns Promise resolving to variant object with name and payload, or null if no variant
+     *
+     * @example
+     * ```typescript
+     * const variant = await client.getVariant('ab-test', {
+     *   userId: '123'
+     * });
+     *
+     * if (variant?.name === 'variant-a') {
+     *   // Variant A logic
+     * } else if (variant?.name === 'variant-b') {
+     *   // Variant B logic
+     * }
+     * ```
+     */
+    getVariant(flagName: string, context?: FeatureFlagContext): Promise<{
+        name: string;
+        payload: any;
+    } | null>;
+    /**
+     * Evaluates multiple feature flags in a single request
+     *
+     * This method is more efficient than calling isEnabled multiple times
+     * as it reduces the number of HTTP requests.
+     *
+     * @param flagNames - Array of feature flag names to evaluate
+     * @param context - Optional evaluation context
+     * @returns Promise resolving to a Map of flag names to evaluation results
+     *
+     * @example
+     * ```typescript
+     * const results = await client.evaluateFlags(
+     *   ['feature-a', 'feature-b', 'ab-test'],
+     *   { userId: '123', tenantId: 'tenant-1' }
+     * );
+     *
+     * const featureAEnabled = results.get('feature-a')?.enabled ?? false;
+     * const abTestVariant = results.get('ab-test')?.variant;
+     * ```
+     */
+    evaluateFlags(flagNames: string[], context?: FeatureFlagContext): Promise<Map<string, FlagEvaluationResult>>;
+    /**
+     * Gets the configured gateway URL
+     * Useful for debugging and logging purposes
+     */
+    getGatewayUrl(): string;
+}
+//# sourceMappingURL=FeatureFlagsClient.d.ts.map

package/dist/nestjs/FeatureFlagsClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeatureFlagsClient.d.ts","sourceRoot":"","sources":["../../src/nestjs/FeatureFlagsClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,kBAAkB;IAIJ,OAAO,CAAC,QAAQ,CAAC,UAAU;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW;IAJ9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;gBAGpB,UAAU,EAAE,MAAM,EACzC,WAAW,EAAE,WAAW;IAG3C;;;;;;;;;;;;;;;OAeG;IACG,SAAS,CACb,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,OAAe,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,OAAO,CAAC;IAmBnB;;;;;;;;;;;;;;;;;;;OAmBG;IACG,UAAU,CACd,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI,CAAC;IA0BjD;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,aAAa,CACjB,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IA6B7C;;;OAGG;IACH,aAAa,IAAI,MAAM;CAGxB"}