facecog-liveness-showcase 0.0.1

package/projects/facecog-liveness-verification/src/lib/models/utils/pose.utils.ts

@@ -0,0 +1,59 @@
+import { PoseDefinition } from '../../interfaces/pose-definition.interface';
+import { CustomPoseData } from '../../interfaces/custom-pose-data.interface';
+import { PoseCategory } from '../../types/pose-category.type';
+import { PoseDifficulty } from '../../types/pose-difficulty.type';
+import { POSE_DEFINITIONS } from '../constants/pose-definitions.constant';
+
+/**
+ * Get poses filtered by category
+ */
+export function getPosesByCategory(category: PoseCategory): PoseDefinition[] {
+  return POSE_DEFINITIONS.filter(pose => pose.category === category);
+}
+
+/**
+ * Get poses filtered by difficulty
+ */
+export function getPosesByDifficulty(difficulty: PoseDifficulty): PoseDefinition[] {
+  return POSE_DEFINITIONS.filter(pose => pose.difficulty === difficulty);
+}
+
+/**
+ * Get a pose by its ID
+ */
+export function getPoseById(id: number): PoseDefinition | undefined {
+  return POSE_DEFINITIONS.find(pose => pose.id === id);
+}
+
+/**
+ * Convert backend CustomPoseData to PoseDefinition
+ */
+export function customPoseToPoseDefinition(customPose: CustomPoseData): PoseDefinition {
+  return {
+    id: customPose.id + 10000, // Offset to avoid ID conflicts with static poses
+    name: customPose.name,
+    description: customPose.description,
+    category: customPose.category as PoseCategory,
+    imagePath: '', // Not used for custom poses
+    imageBlobUrl: customPose.imageBlobUrl,
+    detectionStrategy: (customPose.detectionStrategy || 'openpose') as any,
+    difficulty: customPose.difficulty as PoseDifficulty,
+    poseKeypoints: customPose.poseKeypoints,
+    isCustom: true
+  };
+}
+
+/**
+ * Merge static poses with custom poses
+ */
+export function mergeCustomPoses(customPoses: CustomPoseData[]): PoseDefinition[] {
+  const customPoseDefinitions = customPoses.map(customPoseToPoseDefinition);
+  return [...POSE_DEFINITIONS, ...customPoseDefinitions];
+}
+
+/**
+ * Get only custom poses from a merged list
+ */
+export function getCustomPosesOnly(poses: PoseDefinition[]): PoseDefinition[] {
+  return poses.filter(pose => pose.isCustom);
+}

package/projects/facecog-liveness-verification/src/lib/services/aws-face-liveness.service.ts

@@ -0,0 +1,49 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+import type { LivenessVerificationConfig } from '../interfaces/liveness-verification-config.interface';
+import type {
+  AwsFaceLivenessSessionResponse,
+  AwsFaceLivenessResultsResponse,
+  AwsCredentialsResponse
+} from '../interfaces/aws-face-liveness.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AwsFaceLivenessService {
+  private apiUrl: string;
+
+  constructor(
+    private http: HttpClient,
+    @Optional() @Inject(LIVENESS_VERIFICATION_CONFIG) config?: LivenessVerificationConfig | null
+  ) {
+    this.apiUrl = config?.apiUrl || 'http://localhost:3002';
+  }
+
+  createSession(): Observable<AwsFaceLivenessSessionResponse> {
+    return this.http.post<AwsFaceLivenessSessionResponse>(`${this.apiUrl}/liveness/aws-face-liveness/session`, {}).pipe(
+      catchError(e => throwError(() => new Error((e as { error?: { message?: string } })?.error?.message || 'Failed to create AWS Face Liveness session')))
+    );
+  }
+
+  getSessionResults(sessionId: string): Observable<AwsFaceLivenessResultsResponse> {
+    return this.http.get<AwsFaceLivenessResultsResponse>(`${this.apiUrl}/liveness/aws-face-liveness/session/${sessionId}/results`).pipe(
+      catchError(e => throwError(() => new Error((e as { error?: { message?: string } })?.error?.message || 'Failed to get AWS Face Liveness results')))
+    );
+  }
+
+  getCredentials(): Observable<AwsCredentialsResponse> {
+    return this.http.get<AwsCredentialsResponse>(`${this.apiUrl}/liveness/aws-face-liveness/credentials`).pipe(
+      catchError(e => throwError(() => new Error((e as { error?: { message?: string } })?.error?.message || 'Failed to get AWS credentials')))
+    );
+  }
+
+  async getCredentialsAsync(): Promise<AwsCredentialsResponse> {
+    return new Promise((resolve, reject) => {
+      this.getCredentials().subscribe({ next: resolve, error: reject });
+    });
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/backend-http.service.spec.ts

@@ -0,0 +1,111 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { BackendHttpService } from './backend-http.service';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+
+describe('BackendHttpService', () => {
+  let service: BackendHttpService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [BackendHttpService]
+    });
+    service = TestBed.inject(BackendHttpService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => httpMock.verify());
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('createSession sends POST', () => {
+    service.createSession('amazon').subscribe(res => {
+      expect(res.sessionId).toBe('s1');
+    });
+    const req = httpMock.expectOne('http://localhost:3002/liveness/session/create');
+    expect(req.request.method).toBe('POST');
+    expect(req.request.body).toEqual({ backend: 'amazon' });
+    req.flush({ sessionId: 's1' });
+  });
+
+  it('analyzeLiveness sends POST with correct body', () => {
+    service.analyzeLiveness('s1', 'openpose', 'imgdata', ['f1']).subscribe();
+    const req = httpMock.expectOne('http://localhost:3002/liveness/analyze');
+    expect(req.request.body).toEqual({
+      sessionId: 's1',
+      backend: 'openpose',
+      videoBase64: 'imgdata',
+      frames: ['f1']
+    });
+    req.flush({ isLive: true, confidence: 0.95 });
+  });
+
+  it('analyzeWithAllBackends transforms response', () => {
+    service.analyzeWithAllBackends('s1', 'imgdata').subscribe(res => {
+      expect(res.amazon).toBeDefined();
+      expect(res.primary).toBeDefined();
+    });
+    const req = httpMock.expectOne('http://localhost:3002/liveness/analyze-all');
+    req.flush({
+      amazon: { isLive: true, confidence: 0.9 },
+      openpose: { isLive: true, confidence: 0.85 },
+      facetec: null,
+      primary: { isLive: true, confidence: 0.9 },
+      consensus: { agreement: 'unanimous' }
+    });
+  });
+
+  it('analyzeWithSelectedBackends transforms response', () => {
+    service.analyzeWithSelectedBackends('s1', 'imgdata', ['amazon', 'openpose']).subscribe(res => {
+      expect(res.amazon).toBeDefined();
+      expect(res.openpose).toBeDefined();
+    });
+    const req = httpMock.expectOne('http://localhost:3002/liveness/analyze-selected');
+    expect(req.request.body.backends).toEqual(['amazon', 'openpose']);
+    req.flush({
+      results: {
+        amazon: { isLive: true, confidence: 0.9 },
+        openpose: { isLive: true, confidence: 0.85 }
+      },
+      primary: { isLive: true },
+      consensus: { agreement: 'unanimous' }
+    });
+  });
+
+  it('analyzeWithSelectedBackends handles missing results', () => {
+    service.analyzeWithSelectedBackends('s1', 'imgdata', ['amazon']).subscribe(res => {
+      expect(res.openpose).toBeNull();
+      expect(res.facetec).toBeNull();
+    });
+    const req = httpMock.expectOne('http://localhost:3002/liveness/analyze-selected');
+    req.flush({ primary: null, consensus: null });
+  });
+});
+
+describe('BackendHttpService with config', () => {
+  let service: BackendHttpService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [
+        BackendHttpService,
+        { provide: LIVENESS_VERIFICATION_CONFIG, useValue: { apiUrl: 'https://api.prod.com' } }
+      ]
+    });
+    service = TestBed.inject(BackendHttpService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => httpMock.verify());
+
+  it('uses configured apiUrl', () => {
+    service.createSession('amazon').subscribe();
+    httpMock.expectOne('https://api.prod.com/liveness/session/create');
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/backend-http.service.ts

@@ -0,0 +1,130 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { IBackendHttpClient, SessionResponse } from '../interfaces/backend-http-client.interface';
+import { LivenessBackend } from '../types/liveness-backend.type';
+import { AnalyzeResponse } from '../interfaces/analyze-response.interface';
+import { MultiBackendAnalyzeResponse } from '../interfaces/multi-backend-analyze-response.interface';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+import type { LivenessVerificationConfig } from '../interfaces/liveness-verification-config.interface';
+
+/**
+ * Implementation of IBackendHttpClient that connects to a backend API.
+ * Uses LIVENESS_VERIFICATION_CONFIG.apiUrl when provided.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BackendHttpService implements IBackendHttpClient {
+  private baseUrl: string;
+  private apiUrl: string;
+
+  constructor(
+    private http: HttpClient,
+    @Optional() @Inject(LIVENESS_VERIFICATION_CONFIG) config?: LivenessVerificationConfig | null
+  ) {
+    this.baseUrl = config?.apiUrl || 'http://localhost:3002';
+    this.apiUrl = `${this.baseUrl}/liveness`;
+  }
+
+  createSession(backend: LivenessBackend): Observable<SessionResponse> {
+    return this.http.post<SessionResponse>(`${this.apiUrl}/session/create`, { backend });
+  }
+
+  analyzeLiveness(
+    sessionId: string,
+    backend: LivenessBackend,
+    imageData: string,
+    frames?: string[]
+  ): Observable<AnalyzeResponse> {
+    return this.http.post<AnalyzeResponse>(`${this.apiUrl}/analyze`, {
+      sessionId,
+      backend,
+      videoBase64: imageData,
+      frames
+    });
+  }
+
+  analyzeWithAllBackends(
+    sessionId: string,
+    imageData: string
+  ): Observable<MultiBackendAnalyzeResponse> {
+    return this.http.post<unknown>(`${this.apiUrl}/analyze-all`, {
+      sessionId,
+      videoBase64: imageData
+    }).pipe(
+      map(response => this.transformToMultiBackendResponse(response as Record<string, unknown>))
+    );
+  }
+
+  analyzeWithSelectedBackends(
+    sessionId: string,
+    imageData: string,
+    backends: LivenessBackend[]
+  ): Observable<MultiBackendAnalyzeResponse> {
+    return this.http.post<unknown>(`${this.apiUrl}/analyze-selected`, {
+      sessionId,
+      videoBase64: imageData,
+      backends
+    }).pipe(
+      map(response => this.transformSelectedBackendsResponse(response as Record<string, unknown>))
+    );
+  }
+
+  uploadVideo(
+    videoBlob: Blob,
+    sessionId: string
+  ): Observable<{ success: boolean; videoUrl: string; sessionId: string }> {
+    return new Observable(observer => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        const base64 = (reader.result as string).split(',')[1];
+        this.http.post<{ success: boolean; videoUrl: string; sessionId: string }>(
+          `${this.apiUrl}/upload-video`,
+          { sessionId, videoBase64: base64 }
+        ).subscribe({
+          next: (result) => { observer.next(result); observer.complete(); },
+          error: (err) => observer.error(err)
+        });
+      };
+      reader.onerror = () => observer.error(new Error('Failed to read video blob'));
+      reader.readAsDataURL(videoBlob);
+    });
+  }
+
+  uploadBase64Image(
+    base64Image: string,
+    sessionId: string
+  ): Observable<{ success: boolean; videoUrl: string; sessionId: string }> {
+    let raw = base64Image;
+    if (raw.includes(',')) {
+      raw = raw.split(',')[1];
+    }
+    return this.http.post<{ success: boolean; videoUrl: string; sessionId: string }>(
+      `${this.apiUrl}/upload-video`,
+      { sessionId, videoBase64: raw }
+    );
+  }
+
+  private transformToMultiBackendResponse(response: Record<string, unknown>): MultiBackendAnalyzeResponse {
+    return {
+      amazon: response['amazon'] as MultiBackendAnalyzeResponse['amazon'],
+      openpose: response['openpose'] as MultiBackendAnalyzeResponse['openpose'],
+      facetec: response['facetec'] as MultiBackendAnalyzeResponse['facetec'],
+      primary: response['primary'] as MultiBackendAnalyzeResponse['primary'],
+      consensus: response['consensus'] as MultiBackendAnalyzeResponse['consensus']
+    };
+  }
+
+  private transformSelectedBackendsResponse(response: Record<string, unknown>): MultiBackendAnalyzeResponse {
+    const results = response['results'] as Record<string, unknown> | undefined;
+    return {
+      amazon: results?.['amazon'] as MultiBackendAnalyzeResponse['amazon'] || null,
+      openpose: results?.['openpose'] as MultiBackendAnalyzeResponse['openpose'] || null,
+      facetec: results?.['facetec'] as MultiBackendAnalyzeResponse['facetec'] || null,
+      primary: response['primary'] as MultiBackendAnalyzeResponse['primary'],
+      consensus: response['consensus'] as MultiBackendAnalyzeResponse['consensus']
+    };
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/backends/azure-backend.service.spec.ts

@@ -0,0 +1,69 @@
+import { TestBed } from '@angular/core/testing';
+import { of, throwError } from 'rxjs';
+import { AzureBackendService } from './azure-backend.service';
+import { BACKEND_HTTP_CLIENT } from '../../interfaces/backend-http-client.interface';
+
+describe('AzureBackendService', () => {
+  describe('without backend client', () => {
+    let service: AzureBackendService;
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({ providers: [AzureBackendService] });
+      service = TestBed.inject(AzureBackendService);
+    });
+
+    it('should be created', () => { expect(service).toBeTruthy(); });
+    it('isAvailable returns false', () => { expect(service.isAvailable()).toBe(false); });
+    it('getName returns azure', () => { expect(service.getName()).toBe('azure'); });
+
+    it('verifyLiveness throws error without client', (done) => {
+      service.verifyLiveness('img').subscribe({
+        error: (err) => {
+          expect(err.message).toContain('Backend HTTP client not configured');
+          done();
+        }
+      });
+    });
+  });
+
+  describe('with backend client', () => {
+    let service: AzureBackendService;
+    let mockClient: any;
+
+    beforeEach(() => {
+      mockClient = {
+        createSession: jest.fn().mockReturnValue(of({ sessionId: 's1' })),
+        analyzeLiveness: jest.fn().mockReturnValue(of({ isLive: true, confidence: 0.88, metadata: { backend: 'azure' } })),
+      };
+
+      TestBed.configureTestingModule({
+        providers: [
+          AzureBackendService,
+          { provide: BACKEND_HTTP_CLIENT, useValue: mockClient }
+        ]
+      });
+      service = TestBed.inject(AzureBackendService);
+    });
+
+    it('isAvailable returns true', () => { expect(service.isAvailable()).toBe(true); });
+
+    it('verifyLiveness creates session and analyzes', (done) => {
+      service.verifyLiveness('imgdata').subscribe(res => {
+        expect(res.isLive).toBe(true);
+        expect(res.confidence).toBe(0.88);
+        expect(mockClient.createSession).toHaveBeenCalledWith('azure');
+        done();
+      });
+    });
+
+    it('verifyLiveness handles error', (done) => {
+      mockClient.createSession.mockReturnValue(throwError(() => new Error('Network error')));
+      service.verifyLiveness('imgdata').subscribe({
+        error: (err) => {
+          expect(err.message).toContain('Azure Face API verification failed');
+          done();
+        }
+      });
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/backends/azure-backend.service.ts

@@ -0,0 +1,72 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { Observable, switchMap, map, catchError, throwError, retry, timeout, timer } from 'rxjs';
+import { BackendResponse } from '../../interfaces/backend-response.interface';
+import { IBackendAdapter } from '../../interfaces/backend-adapter.interface';
+import { IBackendHttpClient, BACKEND_HTTP_CLIENT } from '../../interfaces/backend-http-client.interface';
+
+/**
+ * Azure Face API Liveness Backend
+ * Connects to Express backend API which calls Azure Face API
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class AzureBackendService implements IBackendAdapter {
+  private readonly REQUEST_TIMEOUT = 30000; // 30 seconds
+  private readonly MAX_RETRIES = 3;
+
+  constructor(
+    @Optional() @Inject(BACKEND_HTTP_CLIENT) private backendClient: IBackendHttpClient | null
+  ) {}
+
+  verifyLiveness(imageData: string, videoBlob?: Blob): Observable<BackendResponse> {
+    if (!this.backendClient) {
+      console.warn('[AzureBackend] No backend HTTP client configured');
+      return throwError(() => new Error('Backend HTTP client not configured. Provide BACKEND_HTTP_CLIENT.'));
+    }
+
+    // Create session with Azure backend
+    return this.backendClient.createSession('azure').pipe(
+      timeout(this.REQUEST_TIMEOUT),
+      switchMap(session => {
+        // Analyze liveness with the session
+        return this.backendClient!.analyzeLiveness(
+          session.sessionId,
+          'azure',
+          imageData,
+          [imageData] // Send as frames array
+        );
+      }),
+      timeout(this.REQUEST_TIMEOUT),
+      retry({
+        count: this.MAX_RETRIES,
+        delay: (error, retryCount) => {
+          console.warn(`Azure backend retry attempt ${retryCount}/${this.MAX_RETRIES}`, error);
+          // Exponential backoff: 1s, 2s, 4s
+          const delayMs = Math.min(1000 * Math.pow(2, retryCount - 1), 5000);
+          return timer(delayMs);
+        }
+      }),
+      map(response => ({
+        isLive: response.isLive,
+        confidence: response.confidence,
+        details: response.metadata
+      })),
+      catchError(error => {
+        console.error('Azure backend error after retries:', error);
+        if (error.name === 'TimeoutError') {
+          return throwError(() => new Error('Azure Face API request timed out. Please try again.'));
+        }
+        return throwError(() => new Error('Azure Face API verification failed. Please check your connection.'));
+      })
+    );
+  }
+
+  isAvailable(): boolean {
+    return this.backendClient !== null;
+  }
+
+  getName(): string {
+    return 'azure';
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/backends/facetec-backend.service.spec.ts

@@ -0,0 +1,24 @@
+import { TestBed } from '@angular/core/testing';
+import { FaceTecBackendService } from './facetec-backend.service';
+
+describe('FaceTecBackendService', () => {
+  let service: FaceTecBackendService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({ providers: [FaceTecBackendService] });
+    service = TestBed.inject(FaceTecBackendService);
+  });
+
+  it('should be created', () => { expect(service).toBeTruthy(); });
+  it('isAvailable returns false', () => { expect(service.isAvailable()).toBe(false); });
+  it('getName returns facetec', () => { expect(service.getName()).toBe('facetec'); });
+
+  it('verifyLiveness throws not configured error', (done) => {
+    service.verifyLiveness('img').subscribe({
+      error: (err) => {
+        expect(err.message).toContain('FaceTec backend not configured');
+        done();
+      }
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/backends/facetec-backend.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { BackendResponse } from '../../interfaces/backend-response.interface';
+import { IBackendAdapter } from '../../interfaces/backend-adapter.interface';
+
+/**
+ * FaceTec 3D Liveness Backend
+ * To implement: Install FaceTec Browser SDK and configure
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class FaceTecBackendService implements IBackendAdapter {
+
+  constructor() {}
+
+  verifyLiveness(imageData: string, videoBlob?: Blob): Observable<BackendResponse> {
+    // TODO: Implement FaceTec 3D Liveness
+    // 1. Include FaceTec SDK in project
+    // 2. Configure production key
+    // 3. Initialize FaceTec session
+
+    console.warn('FaceTec backend not implemented yet');
+    return throwError(() => new Error('FaceTec backend not configured'));
+  }
+
+  isAvailable(): boolean {
+    // Check if FaceTec SDK is loaded
+    return false;
+  }
+
+  getName(): string {
+    return 'facetec';
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/backends/mock-backend.service.spec.ts

@@ -0,0 +1,36 @@
+import { TestBed } from '@angular/core/testing';
+import { MockBackendService } from './mock-backend.service';
+
+describe('MockBackendService', () => {
+  let service: MockBackendService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({ providers: [MockBackendService] });
+    service = TestBed.inject(MockBackendService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('isAvailable returns true', () => {
+    expect(service.isAvailable()).toBe(true);
+  });
+
+  it('getName returns mock', () => {
+    expect(service.getName()).toBe('mock');
+  });
+
+  it('verifyLiveness returns a BackendResponse observable', (done) => {
+    service.verifyLiveness('base64data').subscribe(res => {
+      expect(res).toBeDefined();
+      expect(typeof res.isLive).toBe('boolean');
+      expect(typeof res.confidence).toBe('number');
+      expect(res.confidence).toBeGreaterThanOrEqual(0.7);
+      expect(res.confidence).toBeLessThanOrEqual(1.0);
+      expect((res.details as any).backend).toBe('mock');
+      expect((res.details as any).faceDetected).toBe(true);
+      done();
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/backends/mock-backend.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { Observable, of, delay } from 'rxjs';
+import { BackendResponse } from '../../interfaces/backend-response.interface';
+import { IBackendAdapter } from '../../interfaces/backend-adapter.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MockBackendService implements IBackendAdapter {
+
+  constructor() {}
+
+  /**
+   * Mock liveness verification - simulates backend processing
+   */
+  verifyLiveness(imageData: string, videoBlob?: Blob): Observable<BackendResponse> {
+    const confidence = Math.random() * 0.3 + 0.7; // 70-100%
+    const isLive = confidence >= 0.75;
+
+    return of({
+      isLive,
+      confidence,
+      details: {
+        backend: 'mock',
+        faceDetected: true,
+        spoofDetected: !isLive,
+        qualityScore: confidence
+      }
+    }).pipe(delay(1500));
+  }
+
+  isAvailable(): boolean {
+    return true;
+  }
+
+  getName(): string {
+    return 'mock';
+  }
+}