@design.estate/dees-wcctools 1.3.0 → 2.0.1

package/dist_ts_web/elements/wcctools.helpers.d.ts

@@ -1,3 +1,16 @@
 import type { TemplateResult } from 'lit';
 export type TTemplateFactory = () => TemplateResult | Promise<TemplateResult>;
+export type TDemoDefinition = TTemplateFactory | TTemplateFactory[];
 export declare const resolveTemplateFactory: (factoryArg: TTemplateFactory) => Promise<TemplateResult>;
+/**
+ * Get the number of demos for an element
+ */
+export declare const getDemoCount: (demo: TDemoDefinition) => number;
+/**
+ * Get a specific demo by index (0-based internally, displayed as 1-based)
+ */
+export declare const getDemoAtIndex: (demo: TDemoDefinition, index: number) => TTemplateFactory | null;
+/**
+ * Check if an element has multiple demos
+ */
+export declare const hasMultipleDemos: (demo: TDemoDefinition) => boolean;

package/dist_ts_web/elements/wcctools.helpers.js

@@ -1,4 +1,29 @@
 export const resolveTemplateFactory = async (factoryArg) => {
     return await Promise.resolve(factoryArg());
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2NjdG9vbHMuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3dlYi9lbGVtZW50cy93Y2N0b29scy5oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLEtBQUssRUFDekMsVUFBNEIsRUFDSCxFQUFFO0lBQzNCLE9BQU8sTUFBTSxPQUFPLENBQUMsT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUM7QUFDN0MsQ0FBQyxDQUFDIn0=
+/**
+ * Get the number of demos for an element
+ */
+export const getDemoCount = (demo) => {
+    if (Array.isArray(demo)) {
+        return demo.length;
+    }
+    return 1;
+};
+/**
+ * Get a specific demo by index (0-based internally, displayed as 1-based)
+ */
+export const getDemoAtIndex = (demo, index) => {
+    if (Array.isArray(demo)) {
+        return demo[index] ?? null;
+    }
+    // Single demo - only index 0 is valid
+    return index === 0 ? demo : null;
+};
+/**
+ * Check if an element has multiple demos
+ */
+export const hasMultipleDemos = (demo) => {
+    return Array.isArray(demo) && demo.length > 1;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2NjdG9vbHMuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3dlYi9lbGVtZW50cy93Y2N0b29scy5oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLEtBQUssRUFDekMsVUFBNEIsRUFDSCxFQUFFO0lBQzNCLE9BQU8sTUFBTSxPQUFPLENBQUMsT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUM7QUFDN0MsQ0FBQyxDQUFDO0FBRUY7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxJQUFxQixFQUFVLEVBQUU7SUFDNUQsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDeEIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ3JCLENBQUM7SUFDRCxPQUFPLENBQUMsQ0FBQztBQUNYLENBQUMsQ0FBQztBQUVGOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLENBQUMsSUFBcUIsRUFBRSxLQUFhLEVBQTJCLEVBQUU7SUFDOUYsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDeEIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksSUFBSSxDQUFDO0lBQzdCLENBQUM7SUFDRCxzQ0FBc0M7SUFDdEMsT0FBTyxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztBQUNuQyxDQUFDLENBQUM7QUFFRjs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMsSUFBcUIsRUFBVyxFQUFFO0lBQ2pFLE9BQU8sS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxJQUFJLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQztBQUNoRCxDQUFDLENBQUMifQ==

package/dist_ts_web/services/ffmpeg.service.d.ts

@@ -0,0 +1,42 @@
+/**
+ * FFmpegService - Handles client-side video format conversion using FFmpeg.wasm
+ * Uses a custom worker implementation to bypass COEP/CORS issues with the standard library
+ */
+export interface IConversionProgress {
+    stage: 'loading' | 'converting' | 'finalizing';
+    progress: number;
+    message: string;
+}
+export interface IConversionOptions {
+    inputBlob: Blob;
+    outputFormat: 'mp4' | 'webm';
+    onProgress?: (progress: IConversionProgress) => void;
+}
+export declare class FFmpegService {
+    private worker;
+    private core;
+    private loadPromise;
+    private messageId;
+    private pendingMessages;
+    private onLog?;
+    private onProgress?;
+    /**
+     * Lazy load FFmpeg.wasm from CDN using custom worker
+     */
+    ensureLoaded(onProgress?: (progress: IConversionProgress) => void): Promise<void>;
+    private loadFFmpeg;
+    private sendMessage;
+    /**
+     * Convert WebM blob to MP4
+     */
+    convertToMp4(options: IConversionOptions): Promise<Blob>;
+    /**
+     * Check if FFmpeg is currently loaded
+     */
+    get isLoaded(): boolean;
+    /**
+     * Terminate FFmpeg worker to free resources
+     */
+    terminate(): Promise<void>;
+}
+export declare function getFFmpegService(): FFmpegService;

package/dist_ts_web/services/ffmpeg.service.js

@@ -0,0 +1,276 @@
+/**
+ * FFmpegService - Handles client-side video format conversion using FFmpeg.wasm
+ * Uses a custom worker implementation to bypass COEP/CORS issues with the standard library
+ */
+export class FFmpegService {
+    worker = null;
+    core = null;
+    loadPromise = null;
+    messageId = 0;
+    pendingMessages = new Map();
+    onLog;
+    onProgress;
+    /**
+     * Lazy load FFmpeg.wasm from CDN using custom worker
+     */
+    async ensureLoaded(onProgress) {
+        if (this.worker && this.core)
+            return;
+        if (this.loadPromise) {
+            await this.loadPromise;
+            return;
+        }
+        this.loadPromise = this.loadFFmpeg(onProgress);
+        await this.loadPromise;
+    }
+    async loadFFmpeg(onProgress) {
+        console.log('[FFmpeg] Starting FFmpeg load with custom worker...');
+        onProgress?.({
+            stage: 'loading',
+            progress: 0,
+            message: 'Loading FFmpeg library...'
+        });
+        // Import toBlobURL utility
+        const { toBlobURL } = await import('@ffmpeg/util');
+        // Use jsdelivr CDN (has proper CORS/CORP headers)
+        const coreBaseURL = 'https://cdn.jsdelivr.net/npm/@ffmpeg/core@0.12.9/dist/umd';
+        onProgress?.({
+            stage: 'loading',
+            progress: 10,
+            message: 'Downloading FFmpeg core (~31MB)...'
+        });
+        console.log('[FFmpeg] Creating blob URLs...');
+        const coreURL = await toBlobURL(`${coreBaseURL}/ffmpeg-core.js`, 'text/javascript');
+        const wasmURL = await toBlobURL(`${coreBaseURL}/ffmpeg-core.wasm`, 'application/wasm');
+        console.log('[FFmpeg] Blob URLs created');
+        onProgress?.({
+            stage: 'loading',
+            progress: 50,
+            message: 'Initializing FFmpeg...'
+        });
+        // Create custom worker code that bypasses @ffmpeg/ffmpeg wrapper issues
+        const workerCode = `
+      let ffmpeg = null;
+
+      self.onmessage = async (e) => {
+        const { id, type, data } = e.data;
+
+        try {
+          switch (type) {
+            case 'LOAD': {
+              const { coreURL, wasmURL } = data;
+              console.log('[FFmpeg Worker] Loading core...');
+              importScripts(coreURL);
+
+              console.log('[FFmpeg Worker] Initializing with WASM...');
+              ffmpeg = await self.createFFmpegCore({
+                mainScriptUrlOrBlob: coreURL + '#' + btoa(JSON.stringify({ wasmURL }))
+              });
+
+              // Set up logging
+              ffmpeg.setLogger((log) => {
+                console.log('[FFmpeg Worker Log]', log);
+                self.postMessage({ type: 'LOG', data: log });
+              });
+
+              // Set up progress - progress is an object { ratio: 0-1, time: seconds }
+              ffmpeg.setProgress((progress) => {
+                const ratio = typeof progress === 'number' ? progress : (progress.ratio || 0);
+                console.log('[FFmpeg Worker Progress]', ratio);
+                self.postMessage({ type: 'PROGRESS', data: ratio });
+              });
+
+              console.log('[FFmpeg Worker] Core initialized successfully');
+              console.log('[FFmpeg Worker] Available methods:', Object.keys(ffmpeg).join(', '));
+              self.postMessage({ id, type: 'LOAD', data: true });
+              break;
+            }
+
+            case 'EXEC': {
+              const { args, timeout = -1 } = data;
+              console.log('[FFmpeg Worker] Executing:', args.join(' '));
+
+              try {
+                ffmpeg.setTimeout(timeout);
+                ffmpeg.exec(...args);
+                const ret = ffmpeg.ret;
+                console.log('[FFmpeg Worker] Exec returned:', ret);
+                ffmpeg.reset();
+                self.postMessage({ id, type: 'EXEC', data: ret });
+              } catch (execErr) {
+                console.error('[FFmpeg Worker] Exec error:', execErr);
+                throw execErr;
+              }
+              break;
+            }
+
+            case 'WRITE_FILE': {
+              const { path, fileData } = data;
+              console.log('[FFmpeg Worker] Writing file:', path, 'size:', fileData.length);
+              ffmpeg.FS.writeFile(path, fileData);
+              self.postMessage({ id, type: 'WRITE_FILE', data: true });
+              break;
+            }
+
+            case 'READ_FILE': {
+              const { path } = data;
+              console.log('[FFmpeg Worker] Reading file:', path);
+              const fileData = ffmpeg.FS.readFile(path);
+              console.log('[FFmpeg Worker] Read file size:', fileData.length);
+              self.postMessage({ id, type: 'READ_FILE', data: fileData }, [fileData.buffer]);
+              break;
+            }
+
+            case 'DELETE_FILE': {
+              const { path } = data;
+              console.log('[FFmpeg Worker] Deleting file:', path);
+              ffmpeg.FS.unlink(path);
+              self.postMessage({ id, type: 'DELETE_FILE', data: true });
+              break;
+            }
+
+            default:
+              throw new Error('Unknown message type: ' + type);
+          }
+        } catch (err) {
+          console.error('[FFmpeg Worker] Error:', err);
+          self.postMessage({ id, type: 'ERROR', data: err.message || String(err) });
+        }
+      };
+    `;
+        // Create worker from blob
+        const workerBlob = new Blob([workerCode], { type: 'text/javascript' });
+        const workerURL = URL.createObjectURL(workerBlob);
+        this.worker = new Worker(workerURL);
+        // Set up message handler
+        this.worker.onmessage = (e) => {
+            const { id, type, data } = e.data;
+            if (type === 'LOG') {
+                console.log('[FFmpeg Log]', data);
+                this.onLog?.(data.message || data);
+                return;
+            }
+            if (type === 'PROGRESS') {
+                this.onProgress?.(data);
+                return;
+            }
+            const pending = this.pendingMessages.get(id);
+            if (pending) {
+                this.pendingMessages.delete(id);
+                if (type === 'ERROR') {
+                    pending.reject(new Error(data));
+                }
+                else {
+                    pending.resolve(data);
+                }
+            }
+        };
+        this.worker.onerror = (e) => {
+            console.error('[FFmpeg] Worker error:', e);
+        };
+        // Initialize FFmpeg in worker
+        console.log('[FFmpeg] Initializing worker...');
+        await this.sendMessage('LOAD', { coreURL, wasmURL });
+        this.core = true; // Mark as loaded
+        console.log('[FFmpeg] Worker initialized successfully');
+        onProgress?.({
+            stage: 'loading',
+            progress: 100,
+            message: 'FFmpeg loaded successfully'
+        });
+    }
+    sendMessage(type, data) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.messageId;
+            this.pendingMessages.set(id, { resolve, reject });
+            this.worker.postMessage({ id, type, data });
+        });
+    }
+    /**
+     * Convert WebM blob to MP4
+     */
+    async convertToMp4(options) {
+        const { inputBlob, onProgress } = options;
+        // Check file size limit (2GB)
+        const MAX_FILE_SIZE = 2 * 1024 * 1024 * 1024;
+        if (inputBlob.size > MAX_FILE_SIZE) {
+            throw new Error('File size exceeds 2GB limit for conversion');
+        }
+        // Set up progress callback
+        this.onProgress = (progress) => {
+            const percent = Math.round((progress || 0) * 100);
+            console.log('[FFmpeg] Conversion progress:', percent + '%');
+            onProgress?.({
+                stage: 'converting',
+                progress: percent,
+                message: `Converting video... ${percent}%`
+            });
+        };
+        await this.ensureLoaded(onProgress);
+        onProgress?.({
+            stage: 'converting',
+            progress: 0,
+            message: 'Preparing video for conversion...'
+        });
+        // Read input blob as Uint8Array
+        const inputData = new Uint8Array(await inputBlob.arrayBuffer());
+        // Write input file to virtual filesystem
+        await this.sendMessage('WRITE_FILE', { path: 'input.webm', fileData: inputData });
+        // Execute conversion with optimized settings for web playback
+        await this.sendMessage('EXEC', {
+            args: [
+                '-i', 'input.webm',
+                '-c:v', 'libx264',
+                '-preset', 'fast',
+                '-crf', '23',
+                '-c:a', 'aac',
+                '-b:a', '128k',
+                '-movflags', '+faststart',
+                'output.mp4'
+            ]
+        });
+        onProgress?.({
+            stage: 'finalizing',
+            progress: 95,
+            message: 'Finalizing video...'
+        });
+        // Read output file
+        const outputData = await this.sendMessage('READ_FILE', { path: 'output.mp4' });
+        // Clean up virtual filesystem
+        await this.sendMessage('DELETE_FILE', { path: 'input.webm' });
+        await this.sendMessage('DELETE_FILE', { path: 'output.mp4' });
+        onProgress?.({
+            stage: 'finalizing',
+            progress: 100,
+            message: 'Conversion complete!'
+        });
+        return new Blob([new Uint8Array(outputData)], { type: 'video/mp4' });
+    }
+    /**
+     * Check if FFmpeg is currently loaded
+     */
+    get isLoaded() {
+        return this.worker !== null && this.core !== null;
+    }
+    /**
+     * Terminate FFmpeg worker to free resources
+     */
+    async terminate() {
+        if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+            this.core = null;
+            this.loadPromise = null;
+            this.pendingMessages.clear();
+        }
+    }
+}
+// Singleton instance for caching
+let ffmpegServiceInstance = null;
+export function getFFmpegService() {
+    if (!ffmpegServiceInstance) {
+        ffmpegServiceInstance = new FFmpegService();
+    }
+    return ffmpegServiceInstance;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmZtcGVnLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c193ZWIvc2VydmljZXMvZmZtcGVnLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBdUJILE1BQU0sT0FBTyxhQUFhO0lBQ2hCLE1BQU0sR0FBa0IsSUFBSSxDQUFDO0lBQzdCLElBQUksR0FBUSxJQUFJLENBQUM7SUFDakIsV0FBVyxHQUF5QixJQUFJLENBQUM7SUFDekMsU0FBUyxHQUFHLENBQUMsQ0FBQztJQUNkLGVBQWUsR0FBeUQsSUFBSSxHQUFHLEVBQUUsQ0FBQztJQUNsRixLQUFLLENBQTZCO0lBQ2xDLFVBQVUsQ0FBOEI7SUFFaEQ7O09BRUc7SUFDSCxLQUFLLENBQUMsWUFBWSxDQUFDLFVBQW9EO1FBQ3JFLElBQUksSUFBSSxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsSUFBSTtZQUFFLE9BQU87UUFFckMsSUFBSSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDckIsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDO1lBQ3ZCLE9BQU87UUFDVCxDQUFDO1FBRUQsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQy9DLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUN6QixDQUFDO0lBRU8sS0FBSyxDQUFDLFVBQVUsQ0FBQyxVQUFvRDtRQUMzRSxPQUFPLENBQUMsR0FBRyxDQUFDLHFEQUFxRCxDQUFDLENBQUM7UUFFbkUsVUFBVSxFQUFFLENBQUM7WUFDWCxLQUFLLEVBQUUsU0FBUztZQUNoQixRQUFRLEVBQUUsQ0FBQztZQUNYLE9BQU8sRUFBRSwyQkFBMkI7U0FDckMsQ0FBQyxDQUFDO1FBRUgsMkJBQTJCO1FBQzNCLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyxNQUFNLE1BQU0sQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUVuRCxrREFBa0Q7UUFDbEQsTUFBTSxXQUFXLEdBQUcsMkRBQTJELENBQUM7UUFFaEYsVUFBVSxFQUFFLENBQUM7WUFDWCxLQUFLLEVBQUUsU0FBUztZQUNoQixRQUFRLEVBQUUsRUFBRTtZQUNaLE9BQU8sRUFBRSxvQ0FBb0M7U0FDOUMsQ0FBQyxDQUFDO1FBRUgsT0FBTyxDQUFDLEdBQUcsQ0FBQyxnQ0FBZ0MsQ0FBQyxDQUFDO1FBQzlDLE1BQU0sT0FBTyxHQUFHLE1BQU0sU0FBUyxDQUFDLEdBQUcsV0FBVyxpQkFBaUIsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO1FBQ3BGLE1BQU0sT0FBTyxHQUFHLE1BQU0sU0FBUyxDQUFDLEdBQUcsV0FBVyxtQkFBbUIsRUFBRSxrQkFBa0IsQ0FBQyxDQUFDO1FBQ3ZGLE9BQU8sQ0FBQyxHQUFHLENBQUMsNEJBQTRCLENBQUMsQ0FBQztRQUUxQyxVQUFVLEVBQUUsQ0FBQztZQUNYLEtBQUssRUFBRSxTQUFTO1lBQ2hCLFFBQVEsRUFBRSxFQUFFO1lBQ1osT0FBTyxFQUFFLHdCQUF3QjtTQUNsQyxDQUFDLENBQUM7UUFFSCx3RUFBd0U7UUFDeEUsTUFBTSxVQUFVLEdBQUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7S0F3RmxCLENBQUM7UUFFRiwwQkFBMEI7UUFDMUIsTUFBTSxVQUFVLEdBQUcsSUFBSSxJQUFJLENBQUMsQ0FBQyxVQUFVLENBQUMsRUFBRSxFQUFFLElBQUksRUFBRSxpQkFBaUIsRUFBRSxDQUFDLENBQUM7UUFDdkUsTUFBTSxTQUFTLEdBQUcsR0FBRyxDQUFDLGVBQWUsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNsRCxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBRXBDLHlCQUF5QjtRQUN6QixJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQThCLEVBQUUsRUFBRTtZQUN6RCxNQUFNLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDO1lBRWxDLElBQUksSUFBSSxLQUFLLEtBQUssRUFBRSxDQUFDO2dCQUNuQixPQUFPLENBQUMsR0FBRyxDQUFDLGNBQWMsRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDbEMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLElBQUksQ0FBQyxPQUFPLElBQUksSUFBSSxDQUFDLENBQUM7Z0JBQ25DLE9BQU87WUFDVCxDQUFDO1lBRUQsSUFBSSxJQUFJLEtBQUssVUFBVSxFQUFFLENBQUM7Z0JBQ3hCLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDeEIsT0FBTztZQUNULENBQUM7WUFFRCxNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUM3QyxJQUFJLE9BQU8sRUFBRSxDQUFDO2dCQUNaLElBQUksQ0FBQyxlQUFlLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDO2dCQUNoQyxJQUFJLElBQUksS0FBSyxPQUFPLEVBQUUsQ0FBQztvQkFDckIsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUNsQyxDQUFDO3FCQUFNLENBQUM7b0JBQ04sT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDeEIsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDLENBQUM7UUFFRixJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sR0FBRyxDQUFDLENBQUMsRUFBRSxFQUFFO1lBQzFCLE9BQU8sQ0FBQyxLQUFLLENBQUMsd0JBQXdCLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDN0MsQ0FBQyxDQUFDO1FBRUYsOEJBQThCO1FBQzlCLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLENBQUMsQ0FBQztRQUMvQyxNQUFNLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDckQsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsQ0FBQyxpQkFBaUI7UUFDbkMsT0FBTyxDQUFDLEdBQUcsQ0FBQywwQ0FBMEMsQ0FBQyxDQUFDO1FBRXhELFVBQVUsRUFBRSxDQUFDO1lBQ1gsS0FBSyxFQUFFLFNBQVM7WUFDaEIsUUFBUSxFQUFFLEdBQUc7WUFDYixPQUFPLEVBQUUsNEJBQTRCO1NBQ3RDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxXQUFXLENBQUMsSUFBdUIsRUFBRSxJQUFVO1FBQ3JELE9BQU8sSUFBSSxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7WUFDckMsTUFBTSxFQUFFLEdBQUcsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDO1lBQzVCLElBQUksQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO1lBQ2xELElBQUksQ0FBQyxNQUFPLENBQUMsV0FBVyxDQUFDLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQy9DLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSyxDQUFDLFlBQVksQ0FBQyxPQUEyQjtRQUM1QyxNQUFNLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUUxQyw4QkFBOEI7UUFDOUIsTUFBTSxhQUFhLEdBQUcsQ0FBQyxHQUFHLElBQUksR0FBRyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQzdDLElBQUksU0FBUyxDQUFDLElBQUksR0FBRyxhQUFhLEVBQUUsQ0FBQztZQUNuQyxNQUFNLElBQUksS0FBSyxDQUFDLDRDQUE0QyxDQUFDLENBQUM7UUFDaEUsQ0FBQztRQUVELDJCQUEyQjtRQUMzQixJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsUUFBZ0IsRUFBRSxFQUFFO1lBQ3JDLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxRQUFRLElBQUksQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUM7WUFDbEQsT0FBTyxDQUFDLEdBQUcsQ0FBQywrQkFBK0IsRUFBRSxPQUFPLEdBQUcsR0FBRyxDQUFDLENBQUM7WUFDNUQsVUFBVSxFQUFFLENBQUM7Z0JBQ1gsS0FBSyxFQUFFLFlBQVk7Z0JBQ25CLFFBQVEsRUFBRSxPQUFPO2dCQUNqQixPQUFPLEVBQUUsdUJBQXVCLE9BQU8sR0FBRzthQUMzQyxDQUFDLENBQUM7UUFDTCxDQUFDLENBQUM7UUFFRixNQUFNLElBQUksQ0FBQyxZQUFZLENBQUMsVUFBVSxDQUFDLENBQUM7UUFFcEMsVUFBVSxFQUFFLENBQUM7WUFDWCxLQUFLLEVBQUUsWUFBWTtZQUNuQixRQUFRLEVBQUUsQ0FBQztZQUNYLE9BQU8sRUFBRSxtQ0FBbUM7U0FDN0MsQ0FBQyxDQUFDO1FBRUgsZ0NBQWdDO1FBQ2hDLE1BQU0sU0FBUyxHQUFHLElBQUksVUFBVSxDQUFDLE1BQU0sU0FBUyxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7UUFFaEUseUNBQXlDO1FBQ3pDLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLEVBQUUsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO1FBRWxGLDhEQUE4RDtRQUM5RCxNQUFNLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFO1lBQzdCLElBQUksRUFBRTtnQkFDSixJQUFJLEVBQUUsWUFBWTtnQkFDbEIsTUFBTSxFQUFFLFNBQVM7Z0JBQ2pCLFNBQVMsRUFBRSxNQUFNO2dCQUNqQixNQUFNLEVBQUUsSUFBSTtnQkFDWixNQUFNLEVBQUUsS0FBSztnQkFDYixNQUFNLEVBQUUsTUFBTTtnQkFDZCxXQUFXLEVBQUUsWUFBWTtnQkFDekIsWUFBWTthQUNiO1NBQ0YsQ0FBQyxDQUFDO1FBRUgsVUFBVSxFQUFFLENBQUM7WUFDWCxLQUFLLEVBQUUsWUFBWTtZQUNuQixRQUFRLEVBQUUsRUFBRTtZQUNaLE9BQU8sRUFBRSxxQkFBcUI7U0FDL0IsQ0FBQyxDQUFDO1FBRUgsbUJBQW1CO1FBQ25CLE1BQU0sVUFBVSxHQUFlLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLENBQUMsQ0FBQztRQUUzRiw4QkFBOEI7UUFDOUIsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLGFBQWEsRUFBRSxFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsQ0FBQyxDQUFDO1FBQzlELE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxhQUFhLEVBQUUsRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLENBQUMsQ0FBQztRQUU5RCxVQUFVLEVBQUUsQ0FBQztZQUNYLEtBQUssRUFBRSxZQUFZO1lBQ25CLFFBQVEsRUFBRSxHQUFHO1lBQ2IsT0FBTyxFQUFFLHNCQUFzQjtTQUNoQyxDQUFDLENBQUM7UUFFSCxPQUFPLElBQUksSUFBSSxDQUFDLENBQUMsSUFBSSxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUMsRUFBRSxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZFLENBQUM7SUFFRDs7T0FFRztJQUNILElBQUksUUFBUTtRQUNWLE9BQU8sSUFBSSxDQUFDLE1BQU0sS0FBSyxJQUFJLElBQUksSUFBSSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUM7SUFDcEQsQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSyxDQUFDLFNBQVM7UUFDYixJQUFJLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNoQixJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ3hCLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDO1lBQ25CLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO1lBQ3hCLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDL0IsQ0FBQztJQUNILENBQUM7Q0FDRjtBQUVELGlDQUFpQztBQUNqQyxJQUFJLHFCQUFxQixHQUF5QixJQUFJLENBQUM7QUFFdkQsTUFBTSxVQUFVLGdCQUFnQjtJQUM5QixJQUFJLENBQUMscUJBQXFCLEVBQUUsQ0FBQztRQUMzQixxQkFBcUIsR0FBRyxJQUFJLGFBQWEsRUFBRSxDQUFDO0lBQzlDLENBQUM7SUFDRCxPQUFPLHFCQUFxQixDQUFDO0FBQy9CLENBQUMifQ==

package/dist_ts_web/services/mp4.service.d.ts

@@ -0,0 +1,32 @@
+/**
+ * MP4Service - Handles client-side video format conversion using Mediabunny
+ * Uses WebCodecs API for hardware-accelerated encoding (10-50x faster than FFmpeg.wasm)
+ * @see https://mediabunny.dev/
+ */
+export interface IConversionProgress {
+    stage: 'loading' | 'converting' | 'finalizing';
+    progress: number;
+    message: string;
+}
+export interface IConversionOptions {
+    inputBlob: Blob;
+    outputFormat: 'mp4' | 'webm';
+    onProgress?: (progress: IConversionProgress) => void;
+}
+export declare class MP4Service {
+    /**
+     * Check if WebCodecs is supported in this browser
+     */
+    static isSupported(): boolean;
+    /**
+     * Check if H.264 encoding is actually available (not just API presence)
+     */
+    static isEncodingSupported(): Promise<boolean>;
+    /**
+     * Convert WebM blob to MP4 using Mediabunny (hardware accelerated via WebCodecs)
+     */
+    convertToMp4(options: IConversionOptions): Promise<Blob>;
+}
+export declare function getMP4Service(): MP4Service;
+export { MP4Service as FFmpegService };
+export { getMP4Service as getFFmpegService };

package/dist_ts_web/services/mp4.service.js

@@ -0,0 +1,139 @@
+/**
+ * MP4Service - Handles client-side video format conversion using Mediabunny
+ * Uses WebCodecs API for hardware-accelerated encoding (10-50x faster than FFmpeg.wasm)
+ * @see https://mediabunny.dev/
+ */
+import { Conversion, Input, Output, ALL_FORMATS, BlobSource, Mp4OutputFormat, BufferTarget, } from 'mediabunny';
+export class MP4Service {
+    /**
+     * Check if WebCodecs is supported in this browser
+     */
+    static isSupported() {
+        return (typeof VideoEncoder !== 'undefined' &&
+            typeof VideoDecoder !== 'undefined');
+    }
+    /**
+     * Check if H.264 encoding is actually available (not just API presence)
+     */
+    static async isEncodingSupported() {
+        if (!this.isSupported())
+            return false;
+        try {
+            const result = await VideoEncoder.isConfigSupported({
+                codec: 'avc1.42E01E', // H.264 Baseline
+                width: 640,
+                height: 480,
+                bitrate: 1_000_000,
+                framerate: 30,
+            });
+            return result.supported === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Convert WebM blob to MP4 using Mediabunny (hardware accelerated via WebCodecs)
+     */
+    async convertToMp4(options) {
+        const { inputBlob, onProgress } = options;
+        if (!MP4Service.isSupported()) {
+            throw new Error('WebCodecs API not supported in this browser. Please use a modern browser (Chrome 94+, Edge 94+, Safari 16.4+, Firefox 130+).');
+        }
+        // Check if encoding is actually available (not just API presence)
+        const encodingSupported = await MP4Service.isEncodingSupported();
+        if (!encodingSupported) {
+            throw new Error('Video encoding is not available in your browser. This may be due to missing hardware encoder support or browser configuration. Try using Chrome with hardware acceleration enabled.');
+        }
+        onProgress?.({
+            stage: 'loading',
+            progress: 0,
+            message: 'Preparing video for conversion...'
+        });
+        try {
+            // Create input from WebM blob
+            const input = new Input({
+                source: new BlobSource(inputBlob),
+                formats: ALL_FORMATS,
+            });
+            onProgress?.({
+                stage: 'loading',
+                progress: 20,
+                message: 'Analyzing input video...'
+            });
+            // Create output for MP4
+            const target = new BufferTarget();
+            const output = new Output({
+                format: new Mp4OutputFormat(),
+                target,
+            });
+            onProgress?.({
+                stage: 'converting',
+                progress: 30,
+                message: 'Starting conversion (hardware accelerated)...'
+            });
+            // Initialize conversion - let mediabunny auto-detect codecs first
+            const conversion = await Conversion.init({
+                input,
+                output,
+            });
+            // Debug: log any issues with the conversion
+            if (!conversion.isValid) {
+                console.error('[MP4Service] Conversion invalid. Discarded tracks:', conversion.discardedTracks);
+                conversion.discardedTracks.forEach((track) => {
+                    console.error('[MP4Service] Track discarded:', track.reason, track);
+                });
+                throw new Error(`Conversion invalid: tracks discarded due to codec issues. Check browser console for details.`);
+            }
+            console.log('[MP4Service] Conversion valid, utilized tracks:', conversion.utilizedTracks);
+            // Execute conversion with progress tracking
+            let lastProgress = 30;
+            const progressInterval = setInterval(() => {
+                // Increment progress gradually during conversion
+                if (lastProgress < 90) {
+                    lastProgress += 5;
+                    onProgress?.({
+                        stage: 'converting',
+                        progress: lastProgress,
+                        message: `Converting... ${lastProgress}%`
+                    });
+                }
+            }, 500);
+            try {
+                await conversion.execute();
+            }
+            finally {
+                clearInterval(progressInterval);
+            }
+            onProgress?.({
+                stage: 'finalizing',
+                progress: 95,
+                message: 'Finalizing MP4 file...'
+            });
+            // Get the output buffer
+            const mp4Buffer = target.buffer;
+            onProgress?.({
+                stage: 'finalizing',
+                progress: 100,
+                message: 'Conversion complete!'
+            });
+            return new Blob([mp4Buffer], { type: 'video/mp4' });
+        }
+        catch (error) {
+            console.error('[MP4Service] Conversion failed:', error);
+            throw new Error(`Video conversion failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+// Singleton instance
+let mp4ServiceInstance = null;
+export function getMP4Service() {
+    if (!mp4ServiceInstance) {
+        mp4ServiceInstance = new MP4Service();
+    }
+    return mp4ServiceInstance;
+}
+// Legacy aliases for compatibility with existing code
+export { MP4Service as FFmpegService };
+export { getMP4Service as getFFmpegService };
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_web/services/recorder.service.js

@@ -189,9 +189,10 @@ export class RecorderService {
             this.durationInterval = null;
         }
     }
-    handleRecordingComplete() {
+    async handleRecordingComplete() {
         // Create blob from recorded chunks
-        this._recordedBlob = new Blob(this.recordedChunks, { type: 'video/webm' });
+        const blob = new Blob(this.recordedChunks, { type: 'video/webm' });
+        this._recordedBlob = blob;
         // Stop all tracks
         if (this.currentStream) {
             this.currentStream.getTracks().forEach(track => track.stop());
@@ -303,4 +304,4 @@ export class RecorderService {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorder.service.js","sourceRoot":"","sources":["../../ts_web/services/recorder.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAgBH,MAAM,OAAO,eAAe;IAC1B,kBAAkB;IACV,aAAa,GAAyB,IAAI,CAAC;IAC3C,cAAc,GAAW,EAAE,CAAC;IAC5B,gBAAgB,GAAkB,IAAI,CAAC;IACvC,SAAS,GAAW,CAAC,CAAC;IACtB,aAAa,GAAgB,IAAI,CAAC;IAClC,YAAY,GAAY,KAAK,CAAC;IAEtC,yBAAyB;IACjB,YAAY,GAAwB,IAAI,CAAC;IACzC,aAAa,GAAwB,IAAI,CAAC;IAC1C,uBAAuB,GAAkB,IAAI,CAAC;IAC9C,gBAAgB,GAAuB,IAAI,CAAC;IAEpD,2BAA2B;IACnB,aAAa,GAAuB,IAAI,CAAC;IAEjD,kBAAkB;IACV,MAAM,GAAoB,EAAE,CAAC;IAErC,YAAY,MAAwB;QAClC,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACvB,CAAC;IACH,CAAC;IAED,iBAAiB;IACjB,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,yBAAyB;IACzB,SAAS,CAAC,MAAuB;QAC/B,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAC9C,CAAC;IAED,kEAAkE;IAElE,KAAK,CAAC,eAAe,CAAC,oBAA6B,KAAK;QACtD,IAAI,CAAC;YACH,IAAI,iBAAiB,EAAE,CAAC;gBACtB,mDAAmD;gBACnD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;gBAC1E,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YACpD,CAAC;YAED,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,gBAAgB,EAAE,CAAC;YAChE,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC;QACtD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;YACnD,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,QAAgB;QACzC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAE3B,IAAI,CAAC,QAAQ;YAAE,OAAO;QAEtB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC;gBACvD,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE;aACzC,CAAC,CAAC;YAEH,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;YAC/B,IAAI,CAAC,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;YACvC,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;YACjE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;YACxD,IAAI,CAAC,aAAa,CAAC,OAAO,GAAG,GAAG,CAAC;YACjC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAEnC,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;YAEvE,IAAI,CAAC,uBAAuB,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE;gBACrD,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;oBACvB,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;oBACnD,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC;oBACrE,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;oBACnD,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC,KAAK,CAAC,CAAC;gBAC1C,CAAC;YACH,CAAC,EAAE,EAAE,CAAC,CAAC;QACT,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,kCAAkC,EAAE,KAAK,CAAC,CAAC;YACzD,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED,mBAAmB;QACjB,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;YACjC,aAAa,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;YAC5C,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;QACtC,CAAC;QACD,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;YAC1B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC3B,CAAC;QACD,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YACjE,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC/B,CAAC;QACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAED,8DAA8D;IAE9D,KAAK,CAAC,cAAc,CAAC,OAA0B;QAC7C,IAAI,CAAC;YACH,yCAAyC;YACzC,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAE3B,iCAAiC;YACjC,MAAM,mBAAmB,GAA8B;gBACrD,KAAK,EAAE;oBACL,cAAc,EAAE,OAAO,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;iBAC3C;gBAC1B,KAAK,EAAE,KAAK;aACb,CAAC;YAEF,8CAA8C;YAC9C,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBAC/B,mBAA2B,CAAC,gBAAgB,GAAG,IAAI,CAAC;YACvD,CAAC;YAED,MAAM,WAAW,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,eAAe,CAAC,mBAAmB,CAAC,CAAC;YAEtF,8EAA8E;YAC9E,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;gBAC3D,IAAI,CAAC;oBACH,IAAI,YAAY,IAAI,MAAM,EAAE,CAAC;wBAC3B,MAAM,UAAU,GAAG,MAAO,MAAc,CAAC,UAAU,CAAC,WAAW,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;wBACzF,MAAM,CAAC,UAAU,CAAC,GAAG,WAAW,CAAC,cAAc,EAAE,CAAC;wBAClD,MAAO,UAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;oBAC/C,CAAC;gBACH,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,OAAO,CAAC,IAAI,CAAC,oDAAoD,EAAE,CAAC,CAAC,CAAC;gBACxE,CAAC;YACH,CAAC;YAED,sCAAsC;YACtC,IAAI,cAAc,GAAG,WAAW,CAAC;YACjC,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;gBAC1B,IAAI,CAAC;oBACH,MAAM,WAAW,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC;wBAC5D,KAAK,EAAE,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,aAAa,EAAE,EAAE;qBACtD,CAAC,CAAC;oBACH,cAAc,GAAG,IAAI,WAAW,CAAC;wBAC/B,GAAG,WAAW,CAAC,cAAc,EAAE;wBAC/B,GAAG,WAAW,CAAC,cAAc,EAAE;qBAChC,CAAC,CAAC;gBACL,CAAC;gBAAC,OAAO,UAAU,EAAE,CAAC;oBACpB,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,UAAU,CAAC,CAAC;gBACnD,CAAC;YACH,CAAC;YAED,2BAA2B;YAC3B,IAAI,CAAC,aAAa,GAAG,cAAc,CAAC;YAEpC,uBAAuB;YACvB,MAAM,QAAQ,GAAG,aAAa,CAAC,eAAe,CAAC,uBAAuB,CAAC;gBACrE,CAAC,CAAC,uBAAuB;gBACzB,CAAC,CAAC,YAAY,CAAC;YAEjB,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;YACrE,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;YAEzB,IAAI,CAAC,aAAa,CAAC,eAAe,GAAG,CAAC,CAAC,EAAE,EAAE;gBACzC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;oBACpB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBACnC,CAAC;YACH,CAAC,CAAC;YAEF,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAEjE,oDAAoD;YACpD,WAAW,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,GAAG,EAAE;gBAC7C,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;oBACtB,IAAI,CAAC,aAAa,EAAE,CAAC;oBACrB,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,EAAE,CAAC;gBAChC,CAAC;YACH,CAAC,CAAC;YAEF,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,6BAA6B;YAE7D,uBAAuB;YACvB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;YACnB,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE;gBAC9C,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACjD,CAAC,EAAE,IAAI,CAAC,CAAC;YAET,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,2BAA2B,EAAE,KAAK,CAAC,CAAC;YAClD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,KAAc,CAAC,CAAC;YACtC,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED,aAAa;QACX,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;YAClE,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC5B,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,aAAa,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACrC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC/B,CAAC;IACH,CAAC;IAEO,uBAAuB;QAC7B,mCAAmC;QACnC,IAAI,CAAC,aAAa,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;QAE3E,kBAAkB;QAClB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YAC9D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACxD,CAAC;IAED,0DAA0D;IAE1D,KAAK,CAAC,kBAAkB,CACtB,YAA8B,EAC9B,SAAiB,EACjB,OAAe;QAEf,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,uCAAuC;YACvC,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAChD,MAAM,CAAC,KAAK,GAAG,YAAY,CAAC,UAAU,IAAI,IAAI,CAAC;YAC/C,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,WAAW,IAAI,GAAG,CAAC;YAChD,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAEpC,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,MAAM,CAAC,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC,CAAC;gBAClD,OAAO;YACT,CAAC;YAED,iCAAiC;YACjC,MAAM,YAAY,GAAG,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;YAE9C,0CAA0C;YAC1C,IAAI,cAA2B,CAAC;YAEhC,IAAI,CAAC;gBACH,gDAAgD;gBAChD,MAAM,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC;gBACpC,MAAM,MAAM,GAAG,QAAQ,CAAC,wBAAwB,CAAC,YAAY,CAAC,CAAC;gBAC/D,MAAM,WAAW,GAAG,QAAQ,CAAC,4BAA4B,EAAE,CAAC;gBAC5D,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gBAC5B,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,6BAA6B;gBAEnE,6DAA6D;gBAC7D,cAAc,GAAG,IAAI,WAAW,CAAC;oBAC/B,GAAG,YAAY,CAAC,cAAc,EAAE;oBAChC,GAAG,WAAW,CAAC,MAAM,CAAC,cAAc,EAAE;iBACvC,CAAC,CAAC;gBAEH,6BAA6B;gBAC7B,MAAM,OAAO,GAAG,GAAG,EAAE;oBACnB,QAAQ,CAAC,KAAK,EAAE,CAAC;gBACnB,CAAC,CAAC;gBAEF,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YACpH,CAAC;YAAC,OAAO,UAAU,EAAE,CAAC;gBACpB,OAAO,CAAC,IAAI,CAAC,gDAAgD,EAAE,UAAU,CAAC,CAAC;gBAC3E,cAAc,GAAG,YAAY,CAAC;gBAC9B,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YACrH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,mBAAmB,CACzB,KAAuB,EACvB,MAAyB,EACzB,GAA6B,EAC7B,MAAmB,EACnB,SAAiB,EACjB,OAAe,EACf,OAAmB,EACnB,OAA6B,EAC7B,MAA8B;QAE9B,MAAM,QAAQ,GAAG,aAAa,CAAC,eAAe,CAAC,uBAAuB,CAAC;YACrE,CAAC,CAAC,uBAAuB;YACzB,CAAC,CAAC,YAAY,CAAC;QAEjB,MAAM,QAAQ,GAAG,IAAI,aAAa,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QACzD,MAAM,MAAM,GAAW,EAAE,CAAC;QAE1B,QAAQ,CAAC,eAAe,GAAG,CAAC,CAAC,EAAE,EAAE;YAC/B,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;gBACpB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACtB,CAAC;QACH,CAAC,CAAC;QAEF,QAAQ,CAAC,MAAM,GAAG,GAAG,EAAE;YACrB,OAAO,EAAE,CAAC;YACV,OAAO,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC;QACpD,CAAC,CAAC;QAEF,QAAQ,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE;YACvB,OAAO,EAAE,CAAC;YACV,MAAM,CAAC,IAAI,KAAK,CAAC,mBAAmB,GAAG,CAAC,CAAC,CAAC,CAAC;QAC7C,CAAC,CAAC;QAEF,qBAAqB;QACrB,KAAK,CAAC,WAAW,GAAG,SAAS,CAAC;QAE9B,KAAK,CAAC,QAAQ,GAAG,GAAG,EAAE;YACpB,kBAAkB;YAClB,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAEpB,gBAAgB;YAChB,KAAK,CAAC,IAAI,EAAE,CAAC;YAEb,wBAAwB;YACxB,MAAM,SAAS,GAAG,GAAG,EAAE;gBACrB,IAAI,KAAK,CAAC,WAAW,IAAI,OAAO,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;oBAChE,KAAK,CAAC,KAAK,EAAE,CAAC;oBACd,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;oBAEtB,sEAAsE;oBACtE,UAAU,CAAC,GAAG,EAAE;wBACd,IAAI,QAAQ,CAAC,KAAK,KAAK,WAAW,EAAE,CAAC;4BACnC,QAAQ,CAAC,IAAI,EAAE,CAAC;wBAClB,CAAC;oBACH,CAAC,EAAE,GAAG,CAAC,CAAC;oBACR,OAAO;gBACT,CAAC;gBAED,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;gBACxD,qBAAqB,CAAC,SAAS,CAAC,CAAC;YACnC,CAAC,CAAC;YAEF,SAAS,EAAE,CAAC;QACd,CAAC,CAAC;IACJ,CAAC;IAED,oDAAoD;IAEpD,KAAK;QACH,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;QACnB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED,OAAO;QACL,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YAC9D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorder.service.js","sourceRoot":"","sources":["../../ts_web/services/recorder.service.ts"],"names":[],"mappings":"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"}