@jaak.ai/stamps 1.0.0-dev.9 → 2.0.0-beta.1

package/dist/collection/components/my-component/my-component.js

@@ -0,0 +1,1162 @@
+import { h } from "@stencil/core";
+export class JaakStamps {
+    el;
+    debug = false;
+    alignmentTolerance = 10; // Tolerancia en píxeles para considerar un lado alineado (escalado para 320x320)
+    captureCompleted;
+    isReady;
+    isVideoActive = false;
+    statusMessage = 'Presione el botón para activar la cámara';
+    statusColor = '#aaa';
+    bestScore = 0;
+    capturedFullFrame = null;
+    capturedCroppedId = null;
+    capturedBackFullFrame = null;
+    capturedBackCroppedId = null;
+    captureStep = 'front';
+    isCapturing = false;
+    showFlipAnimation = false;
+    showSuccessAnimation = false;
+    shouldMirrorVideo = true;
+    sideAlignment = {
+        top: false,
+        right: false,
+        bottom: false,
+        left: false
+    };
+    isDetectionPaused = false;
+    isLoading = false;
+    isModelPreloaded = false;
+    isMaskReady = false;
+    videoRef;
+    canvasRef;
+    session;
+    startTime;
+    videoStream;
+    animationId;
+    hasScreenshotTaken = false;
+    lastDetectedBox;
+    // Performance optimization properties
+    frameSkipCounter = 0;
+    FRAME_SKIP = 2; // Process every 3rd frame (reduces CPU by ~66%)
+    consecutiveFailures = 0;
+    MAX_FAILURES = 30; // 0.5 seconds without detection
+    lastInferenceTime = 0;
+    MIN_INFERENCE_INTERVAL = 50; // Minimum 50ms between inferences
+    // Canvas pooling for memory optimization
+    preprocessCanvas;
+    preprocessCtx;
+    captureCanvas;
+    captureCtx;
+    MODEL_PATH = "https://storage.googleapis.com/jaak-static/web/component/stamps/detector-nano.onnx";
+    INPUT_SIZE = 320;
+    CONFIDENCE_THRESHOLD = 0.6;
+    // ISO/IEC 7810 ID-1 standard dimensions (85.60mm x 53.98mm)
+    ID1_ASPECT_RATIO = 85.60 / 53.98; // 1.5863320574...
+    debugLog(...args) {
+        if (this.debug) {
+            console.log(...args);
+        }
+    }
+    emitReadyEvent() {
+        const isDocumentReady = !!window.ort && this.isModelPreloaded;
+        this.isReady.emit(isDocumentReady);
+        this.debugLog('🟢 isReady event emitted:', isDocumentReady);
+    }
+    isRearCamera(stream) {
+        const videoTrack = stream.getVideoTracks()[0];
+        if (!videoTrack)
+            return false;
+        const settings = videoTrack.getSettings();
+        return settings.facingMode === 'environment';
+    }
+    async componentDidLoad() {
+        if (!window.ort) {
+            const script = document.createElement('script');
+            script.src = 'https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js';
+            document.head.appendChild(script);
+            // Wait for ONNX runtime to load before emitting ready event
+            script.onload = () => {
+                this.emitReadyEvent();
+            };
+        }
+        else {
+            // ONNX runtime already loaded
+            this.emitReadyEvent();
+        }
+        // Initialize canvas pool for better performance
+        this.initializeCanvasPool();
+        this.setupResizeObserver();
+    }
+    setupResizeObserver() {
+        if ('ResizeObserver' in window && this.canvasRef) {
+            const resizeObserver = new ResizeObserver(() => {
+                this.handleResize();
+            });
+            resizeObserver.observe(this.canvasRef.parentElement);
+        }
+    }
+    handleResize() {
+        if (this.canvasRef) {
+            const container = this.canvasRef.parentElement;
+            const rect = container.getBoundingClientRect();
+            // Set canvas size to match container
+            this.canvasRef.width = rect.width;
+            this.canvasRef.height = rect.height;
+            // Update mask positioning based on container and video dimensions
+            this.updateMaskDimensions(rect);
+            this.debugLog('📐 Canvas resized:', { width: rect.width, height: rect.height });
+        }
+    }
+    updateMaskDimensions(containerRect) {
+        if (!this.videoRef)
+            return;
+        const videoWidth = this.videoRef.videoWidth;
+        const videoHeight = this.videoRef.videoHeight;
+        if (videoWidth === 0 || videoHeight === 0)
+            return;
+        // Calculate video aspect ratio and container aspect ratio
+        const videoAspectRatio = videoWidth / videoHeight;
+        const containerAspectRatio = containerRect.width / containerRect.height;
+        // Determine how video fits in container (letterboxed or pillarboxed)
+        let displayedVideoWidth, displayedVideoHeight;
+        let videoOffsetX = 0, videoOffsetY = 0;
+        if (videoAspectRatio > containerAspectRatio) {
+            // Video is wider - letterboxed (black bars top/bottom)
+            displayedVideoWidth = containerRect.width;
+            displayedVideoHeight = containerRect.width / videoAspectRatio;
+            videoOffsetY = (containerRect.height - displayedVideoHeight) / 2;
+        }
+        else {
+            // Video is taller - pillarboxed (black bars left/right)
+            displayedVideoHeight = containerRect.height;
+            displayedVideoWidth = containerRect.height * videoAspectRatio;
+            videoOffsetX = (containerRect.width - displayedVideoWidth) / 2;
+        }
+        // Calculate maximum possible mask size while preserving exact ID-1 aspect ratio
+        // Determine the limiting dimension based on video orientation and ID-1 proportions
+        // Calculate what would be the max width if limited by video height
+        const maxWidthByHeight = displayedVideoHeight * this.ID1_ASPECT_RATIO;
+        let maskWidthInVideo, maskHeightInVideo;
+        if (maxWidthByHeight <= displayedVideoWidth) {
+            // Video height is the limiting factor
+            maskHeightInVideo = displayedVideoHeight * 0.9; // Use 90% of available height
+            maskWidthInVideo = maskHeightInVideo * this.ID1_ASPECT_RATIO;
+        }
+        else {
+            // Video width is the limiting factor
+            maskWidthInVideo = displayedVideoWidth * 0.9; // Use 90% of available width
+            maskHeightInVideo = maskWidthInVideo / this.ID1_ASPECT_RATIO;
+        }
+        // Convert to percentages of the container
+        const maskWidthPercent = (maskWidthInVideo / containerRect.width) * 100;
+        const maskHeightPercent = (maskHeightInVideo / containerRect.height) * 100;
+        // Calculate the center position of the displayed video area
+        const videoCenterX = videoOffsetX + (displayedVideoWidth / 2);
+        const videoCenterY = videoOffsetY + (displayedVideoHeight / 2);
+        // Convert to percentages of the container
+        const videoCenterXPercent = (videoCenterX / containerRect.width) * 100;
+        const videoCenterYPercent = (videoCenterY / containerRect.height) * 100;
+        // Update CSS custom properties for mask sizing and positioning
+        this.el.style.setProperty('--mask-width', `${maskWidthPercent}%`);
+        this.el.style.setProperty('--mask-height', `${maskHeightPercent}%`);
+        this.el.style.setProperty('--mask-center-x', `${videoCenterXPercent}%`);
+        this.el.style.setProperty('--mask-center-y', `${videoCenterYPercent}%`);
+        // Mark mask as ready now that dimensions are calculated
+        this.isMaskReady = true;
+        this.debugLog('🎯 Mask dimensions updated:', {
+            video: { width: videoWidth, height: videoHeight },
+            displayed: { width: displayedVideoWidth, height: displayedVideoHeight },
+            mask: { widthPercent: maskWidthPercent, heightPercent: maskHeightPercent },
+            center: { x: videoCenterXPercent, y: videoCenterYPercent },
+            offset: { x: videoOffsetX, y: videoOffsetY }
+        });
+    }
+    initializeCanvasPool() {
+        // Preprocess canvas - reused for every inference
+        this.preprocessCanvas = document.createElement('canvas');
+        this.preprocessCanvas.width = this.INPUT_SIZE;
+        this.preprocessCanvas.height = this.INPUT_SIZE;
+        this.preprocessCtx = this.preprocessCanvas.getContext('2d', {
+            alpha: false, // No transparency needed
+            willReadFrequently: true // Optimize for frequent getImageData calls
+        });
+        // Capture canvas - reused for screenshots
+        this.captureCanvas = document.createElement('canvas');
+        this.captureCtx = this.captureCanvas.getContext('2d', {
+            alpha: false
+        });
+        this.debugLog('🎨 Canvas pool initialized for performance');
+    }
+    disconnectedCallback() {
+        this.cleanup();
+    }
+    async getCapturedImages() {
+        if (this.captureStep !== 'completed') {
+            throw new Error('El proceso de captura no ha sido completado');
+        }
+        return {
+            front: {
+                fullFrame: this.capturedFullFrame,
+                cropped: this.capturedCroppedId
+            },
+            back: {
+                fullFrame: this.capturedBackFullFrame,
+                cropped: this.capturedBackCroppedId
+            },
+            metadata: {
+                hasBackCapture: !!(this.capturedBackFullFrame && this.capturedBackCroppedId),
+                totalImages: (this.capturedBackFullFrame && this.capturedBackCroppedId) ? 4 : 2
+            }
+        };
+    }
+    async isProcessCompleted() {
+        return this.captureStep === 'completed';
+    }
+    async startCapture() {
+        await this.startDetection();
+    }
+    async stopCapture() {
+        this.exitSession();
+    }
+    async resetCapture() {
+        this.resetDetection();
+    }
+    async getStatus() {
+        return {
+            isVideoActive: this.isVideoActive,
+            captureStep: this.captureStep,
+            statusMessage: this.statusMessage,
+            hasImages: !!(this.capturedFullFrame || this.capturedBackFullFrame),
+            isProcessCompleted: this.captureStep === 'completed',
+            isModelPreloaded: this.isModelPreloaded
+        };
+    }
+    async preloadModel() {
+        if (this.isModelPreloaded || this.session) {
+            this.debugLog('🚀 Model already preloaded or session exists');
+            return { success: true, message: 'Model already loaded' };
+        }
+        try {
+            this.isLoading = true;
+            this.statusMessage = "Precargando modelo de detección...";
+            this.statusColor = "#007bff";
+            const modelPath = this.MODEL_PATH;
+            this.debugLog('🤖 Preloading model:', modelPath);
+            // Configure ONNX Runtime with device-specific optimizations
+            const sessionOptions = this.getSessionOptions();
+            this.session = await window.ort.InferenceSession.create(modelPath, sessionOptions);
+            this.isModelPreloaded = true;
+            this.isLoading = false;
+            this.statusMessage = "Modelo precargado. Listo para comenzar detección";
+            this.statusColor = "#28a745";
+            this.emitReadyEvent();
+            this.debugLog('✅ Model preloaded successfully');
+            return { success: true, message: 'Model preloaded successfully' };
+        }
+        catch (error) {
+            this.debugLog('❌ Error preloading model:', error);
+            this.isLoading = false;
+            this.statusMessage = "Error al precargar el modelo";
+            this.statusColor = "#ff6b6b";
+            return { success: false, error: error.message };
+        }
+    }
+    async skipBackCapture() {
+        if (this.captureStep === 'back' && this.capturedFullFrame) {
+            this.completeProcess(true);
+        }
+    }
+    cleanup() {
+        if (this.animationId) {
+            cancelAnimationFrame(this.animationId);
+        }
+        if (this.videoStream) {
+            this.videoStream.getTracks().forEach(track => track.stop());
+        }
+        // Limpiar canvas en cleanup general
+        if (this.canvasRef) {
+            const ctx = this.canvasRef.getContext("2d");
+            if (ctx) {
+                ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+            }
+        }
+        // OPTIMIZATION: Clean up canvas pool
+        this.cleanupCanvasPool();
+    }
+    cleanupCanvasPool() {
+        // Release canvas references for garbage collection
+        if (this.preprocessCanvas) {
+            this.preprocessCtx = undefined;
+            this.preprocessCanvas = undefined;
+        }
+        if (this.captureCanvas) {
+            this.captureCtx = undefined;
+            this.captureCanvas = undefined;
+        }
+        // Disposed ONNX session
+        if (this.session) {
+            this.session.release?.();
+            this.session = undefined;
+        }
+        this.isModelPreloaded = false;
+        this.debugLog('🧹 Canvas pool cleaned up');
+    }
+    async getMaxResolution() {
+        try {
+            // Primero obtén un stream básico para acceder a las capacidades
+            const tempStream = await navigator.mediaDevices.getUserMedia({
+                video: { facingMode: "environment" }
+            });
+            const videoTrack = tempStream.getVideoTracks()[0];
+            const capabilities = videoTrack.getCapabilities();
+            // Detener el stream temporal
+            tempStream.getTracks().forEach(track => track.stop());
+            // Construir restricciones con resolución optimizada para tablets
+            const constraints = {
+                facingMode: "environment"
+            };
+            if (capabilities.width && capabilities.height) {
+                // Limitar resolución máxima para tablets para evitar problemas de rendimiento
+                const maxWidth = Math.min(capabilities.width.max, 1920);
+                const maxHeight = Math.min(capabilities.height.max, 1080);
+                // Para tablets, usar resolución moderada en lugar de máxima
+                const isTablet = /iPad|Android/i.test(navigator.userAgent) && window.innerWidth >= 768;
+                if (isTablet) {
+                    constraints.width = { ideal: Math.min(maxWidth, 1280) };
+                    constraints.height = { ideal: Math.min(maxHeight, 720) };
+                }
+                else {
+                    constraints.width = { ideal: maxWidth };
+                    constraints.height = { ideal: maxHeight };
+                }
+                this.debugLog('📐 Resolution capabilities:', {
+                    maxWidth: capabilities.width.max,
+                    maxHeight: capabilities.height.max,
+                    selectedWidth: constraints.width.ideal,
+                    selectedHeight: constraints.height.ideal,
+                    isTablet
+                });
+            }
+            return constraints;
+        }
+        catch (err) {
+            this.debugLog('⚠️ Could not get capabilities, using fallback');
+            // Fallback optimizado para tablets
+            const isTablet = /iPad|Android/i.test(navigator.userAgent) && window.innerWidth >= 768;
+            return {
+                facingMode: "environment",
+                width: { ideal: isTablet ? 1280 : 1920 },
+                height: { ideal: isTablet ? 720 : 1080 }
+            };
+        }
+    }
+    async setupCamera() {
+        try {
+            const constraints = await this.getMaxResolution();
+            const stream = await navigator.mediaDevices.getUserMedia({
+                video: constraints,
+                audio: false
+            });
+            if (this.videoRef) {
+                this.videoRef.srcObject = stream;
+                this.videoStream = stream;
+                // Determine if video should be mirrored
+                const isRear = this.isRearCamera(stream);
+                this.shouldMirrorVideo = !isRear;
+                this.debugLog('📹 Rear camera:', isRear);
+                this.debugLog('🪞 Should mirror video:', this.shouldMirrorVideo);
+                return new Promise((resolve) => {
+                    this.videoRef.onloadedmetadata = async () => {
+                        await this.videoRef.play();
+                        this.isVideoActive = true;
+                        // Update mask dimensions once video is loaded
+                        if (this.canvasRef) {
+                            const container = this.canvasRef.parentElement;
+                            const rect = container.getBoundingClientRect();
+                            this.updateMaskDimensions(rect);
+                        }
+                        resolve();
+                    };
+                });
+            }
+        }
+        catch (err) {
+            this.debugLog("❌ No se pudo acceder a la cámara:", err);
+            this.statusMessage = "Error: No se pudo acceder a la cámara.";
+            this.statusColor = "#ff6b6b";
+        }
+    }
+    preprocess(video) {
+        // OPTIMIZATION: Reuse canvas instead of creating new ones
+        if (!this.preprocessCanvas || !this.preprocessCtx) {
+            this.initializeCanvasPool();
+        }
+        // Clear and redraw on reused canvas
+        this.preprocessCtx.clearRect(0, 0, this.INPUT_SIZE, this.INPUT_SIZE);
+        this.preprocessCtx.drawImage(video, 0, 0, this.INPUT_SIZE, this.INPUT_SIZE);
+        const imageData = this.preprocessCtx.getImageData(0, 0, this.INPUT_SIZE, this.INPUT_SIZE);
+        const [R, G, B] = [[], [], []];
+        const { data } = imageData;
+        // Optimized pixel processing
+        for (let i = 0; i < data.length; i += 4) {
+            R.push(data[i] / 255);
+            G.push(data[i + 1] / 255);
+            B.push(data[i + 2] / 255);
+        }
+        const transposedData = new Float32Array(R.concat(G, B));
+        return new window.ort.Tensor("float32", transposedData, [1, 3, this.INPUT_SIZE, this.INPUT_SIZE]);
+    }
+    getSessionOptions() {
+        return {
+            executionProviders: [
+                // Try WebGL first for GPU acceleration, fallback to WASM
+                'webgl',
+                'wasm'
+            ],
+            graphOptimizationLevel: 'all', // Maximum optimization
+            logSeverityLevel: this.debug ? 2 : 4, // Reduce logging overhead in production
+            logVerbosityLevel: 0,
+            enableCpuMemArena: true,
+            enableMemPattern: true,
+            executionMode: 'parallel',
+            interOpNumThreads: 2,
+            intraOpNumThreads: 2,
+        };
+    }
+    async startDetection() {
+        try {
+            // Check if model is already preloaded
+            if (!this.session) {
+                this.isLoading = true;
+                this.statusMessage = "Cargando modelo de detección...";
+                this.statusColor = "#007bff";
+                const modelPath = this.MODEL_PATH;
+                this.debugLog('🤖 Loading model:', modelPath);
+                const sessionOptions = this.getSessionOptions();
+                this.session = await window.ort.InferenceSession.create(modelPath, sessionOptions);
+                this.isModelPreloaded = true;
+                this.emitReadyEvent();
+            }
+            else {
+                this.debugLog('🚀 Using preloaded model');
+                this.statusMessage = "Usando modelo precargado...";
+                this.statusColor = "#007bff";
+            }
+            this.statusMessage = "Configurando cámara...";
+            await this.setupCamera();
+            this.startTime = Date.now();
+            this.isLoading = false;
+            this.detectFrame();
+        }
+        catch (err) {
+            this.debugLog("Error al inicializar:", err);
+            this.statusMessage = "Error al inicializar el detector";
+            this.statusColor = "#ff6b6b";
+            this.isLoading = false;
+        }
+    }
+    async detectFrame() {
+        try {
+            if (!this.videoRef || !this.canvasRef || !this.session)
+                return;
+            // Pausar detección si está marcado como pausado
+            if (this.isDetectionPaused) {
+                // Solo continuar el bucle sin procesar detección
+                if (this.captureStep !== 'completed') {
+                    this.animationId = requestAnimationFrame(() => this.detectFrame());
+                }
+                return;
+            }
+            // OPTIMIZATION 1: Frame skipping for performance
+            this.frameSkipCounter++;
+            if (this.frameSkipCounter <= this.FRAME_SKIP) {
+                if (this.captureStep !== 'completed') {
+                    this.animationId = requestAnimationFrame(() => this.detectFrame());
+                }
+                return;
+            }
+            this.frameSkipCounter = 0;
+            // OPTIMIZATION 2: Throttle inference based on time
+            const currentTime = Date.now();
+            if (currentTime - this.lastInferenceTime < this.MIN_INFERENCE_INTERVAL) {
+                if (this.captureStep !== 'completed') {
+                    this.animationId = requestAnimationFrame(() => this.detectFrame());
+                }
+                return;
+            }
+            this.lastInferenceTime = currentTime;
+            const ctx = this.canvasRef.getContext("2d");
+            const inputTensor = this.preprocess(this.videoRef);
+            const feeds = { [this.session.inputNames[0]]: inputTensor };
+            const results = await this.session.run(feeds);
+            const output = results[this.session.outputNames[0]].data;
+            const finalBoxes = [];
+            for (let i = 0; i < output.length; i += 6) {
+                const [x1, y1, x2, y2, score, classId] = output.slice(i, i + 6);
+                if (score > this.CONFIDENCE_THRESHOLD) {
+                    finalBoxes.push({ x: x1, y: y1, w: x2 - x1, h: y2 - y1, score, classId });
+                    if (this.startTime && Date.now() - this.startTime < 5000) {
+                        const currentBox = { x: x1, y: y1, w: x2 - x1, h: y2 - y1, score };
+                        const isWellPositioned = this.isCardInFrame(currentBox);
+                        const effectiveScore = isWellPositioned ? score * 1.2 : score;
+                        if (effectiveScore > this.bestScore) {
+                            this.bestScore = effectiveScore;
+                        }
+                    }
+                }
+            }
+            // OPTIMIZATION 3: Adaptive frame rate based on detection success
+            if (finalBoxes.length === 0) {
+                this.consecutiveFailures++;
+            }
+            else {
+                this.consecutiveFailures = 0;
+            }
+            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+            if (this.debug) {
+                this.drawDetections(ctx, finalBoxes);
+            }
+            this.updateGuidanceStatus(finalBoxes);
+            this.updateMaskColor(finalBoxes);
+            // Solo continuar si no hemos completado el proceso
+            if (this.captureStep !== 'completed') {
+                // OPTIMIZATION 4: Reduce frame rate when no detection for better battery life
+                if (this.consecutiveFailures > this.MAX_FAILURES) {
+                    // Reduce to ~5fps when no detection for 0.5 seconds
+                    setTimeout(() => this.detectFrame(), 200);
+                }
+                else {
+                    this.animationId = requestAnimationFrame(() => this.detectFrame());
+                }
+            }
+        }
+        catch (e) {
+            this.debugLog("Error en inferencia:", e);
+            // Solo continuar si no hemos completado el proceso
+            if (this.captureStep !== 'completed') {
+                // On error, wait longer before retrying
+                setTimeout(() => this.detectFrame(), 100);
+            }
+        }
+    }
+    isCardInFrame(box) {
+        const cardCenterX = box.x + box.w / 2;
+        const cardCenterY = box.y + box.h / 2;
+        const frameCenterX = this.INPUT_SIZE / 2;
+        const frameCenterY = this.INPUT_SIZE / 2;
+        const toleranceX = 40;
+        const toleranceY = 30;
+        const isCentered = Math.abs(cardCenterX - frameCenterX) < toleranceX &&
+            Math.abs(cardCenterY - frameCenterY) < toleranceY;
+        const isGoodSize = box.w > 150 && box.w < 300 && box.h > 90 && box.h < 200;
+        return isCentered && isGoodSize;
+    }
+    checkSideAlignment(box) {
+        if (!this.videoRef)
+            return { top: false, right: false, bottom: false, left: false };
+        // Get video dimensions to calculate actual mask boundaries in model space
+        const videoWidth = this.videoRef.videoWidth;
+        const videoHeight = this.videoRef.videoHeight;
+        if (videoWidth === 0 || videoHeight === 0) {
+            return { top: false, right: false, bottom: false, left: false };
+        }
+        // Calculate video aspect ratio
+        const videoAspectRatio = videoWidth / videoHeight;
+        // The model sees video stretched to 320x320, but we need to calculate where
+        // the mask should be in this distorted space to match the visual mask
+        // In the visual display, we calculate mask size based on the limiting dimension
+        // We need to replicate this logic but account for the distortion in model space
+        // Calculate the "display" dimensions (what the visual mask calculations use)
+        const containerAspectRatio = 1; // Assume square container for simplicity
+        let displayedVideoWidth, displayedVideoHeight;
+        if (videoAspectRatio > containerAspectRatio) {
+            // Video is wider - letterboxed in display
+            displayedVideoWidth = this.INPUT_SIZE;
+            displayedVideoHeight = this.INPUT_SIZE / videoAspectRatio;
+        }
+        else {
+            // Video is taller - pillarboxed in display  
+            displayedVideoHeight = this.INPUT_SIZE;
+            displayedVideoWidth = this.INPUT_SIZE * videoAspectRatio;
+        }
+        // Calculate mask dimensions using the same logic as updateMaskDimensions
+        const maxWidthByHeight = displayedVideoHeight * this.ID1_ASPECT_RATIO;
+        let visualMaskWidth, visualMaskHeight;
+        if (maxWidthByHeight <= displayedVideoWidth) {
+            // Video height is the limiting factor
+            visualMaskHeight = displayedVideoHeight * 0.9;
+            visualMaskWidth = visualMaskHeight * this.ID1_ASPECT_RATIO;
+        }
+        else {
+            // Video width is the limiting factor
+            visualMaskWidth = displayedVideoWidth * 0.9;
+            visualMaskHeight = visualMaskWidth / this.ID1_ASPECT_RATIO;
+        }
+        // Now map these visual mask dimensions to the distorted model space
+        // The model stretches video to 320x320, so we need to apply the inverse transformation
+        const modelMaskWidth = visualMaskWidth * (this.INPUT_SIZE / displayedVideoWidth);
+        const modelMaskHeight = visualMaskHeight * (this.INPUT_SIZE / displayedVideoHeight);
+        // Calculate mask boundaries in model coordinate system (always centered in 320x320)
+        const maskCenterX = this.INPUT_SIZE / 2;
+        const maskCenterY = this.INPUT_SIZE / 2;
+        const maskLeft = maskCenterX - (modelMaskWidth / 2);
+        const maskRight = maskCenterX + (modelMaskWidth / 2);
+        const maskTop = maskCenterY - (modelMaskHeight / 2);
+        const maskBottom = maskCenterY + (modelMaskHeight / 2);
+        // Obtener las coordenadas del documento detectado
+        let docLeft = box.x;
+        let docRight = box.x + box.w;
+        const docTop = box.y;
+        const docBottom = box.y + box.h;
+        // Si el video está en modo mirror, invertir las coordenadas horizontales
+        if (this.shouldMirrorVideo) {
+            const originalDocLeft = docLeft;
+            const originalDocRight = docRight;
+            docLeft = this.INPUT_SIZE - originalDocRight;
+            docRight = this.INPUT_SIZE - originalDocLeft;
+        }
+        // Tolerancia para considerar que un lado está alineado (en píxeles)
+        const tolerance = this.alignmentTolerance;
+        return {
+            top: Math.abs(docTop - maskTop) <= tolerance,
+            right: Math.abs(docRight - maskRight) <= tolerance,
+            bottom: Math.abs(docBottom - maskBottom) <= tolerance,
+            left: Math.abs(docLeft - maskLeft) <= tolerance
+        };
+    }
+    areAllSidesAligned(alignment) {
+        return alignment.top && alignment.right && alignment.bottom && alignment.left;
+    }
+    updateMaskColor(boxes) {
+        const cardOutline = this.el.shadowRoot?.querySelector('.card-outline');
+        const corners = this.el.shadowRoot?.querySelectorAll('.corner');
+        const topSide = this.el.shadowRoot?.querySelector('.side-top');
+        const rightSide = this.el.shadowRoot?.querySelector('.side-right');
+        const bottomSide = this.el.shadowRoot?.querySelector('.side-bottom');
+        const leftSide = this.el.shadowRoot?.querySelector('.side-left');
+        let bestBox = null;
+        let currentAlignment = { top: false, right: false, bottom: false, left: false };
+        if (boxes.length > 0) {
+            bestBox = boxes.reduce((best, current) => current.score > best.score ? current : best);
+            currentAlignment = this.checkSideAlignment(bestBox);
+            this.sideAlignment = currentAlignment;
+        }
+        else {
+            // Reset alignment when no detection
+            this.sideAlignment = { top: false, right: false, bottom: false, left: false };
+        }
+        // Actualizar colores de cada lado individualmente
+        topSide?.classList.toggle('aligned', currentAlignment.top);
+        rightSide?.classList.toggle('aligned', currentAlignment.right);
+        bottomSide?.classList.toggle('aligned', currentAlignment.bottom);
+        leftSide?.classList.toggle('aligned', currentAlignment.left);
+        // Verificar si todos los lados están alineados
+        const allSidesAligned = this.areAllSidesAligned(currentAlignment);
+        if (allSidesAligned && bestBox) {
+            cardOutline?.classList.add('perfect-match');
+            corners?.forEach(corner => corner.classList.add('perfect-match'));
+            if (!this.hasScreenshotTaken) {
+                this.lastDetectedBox = bestBox;
+                this.takeScreenshot();
+                this.hasScreenshotTaken = true;
+                // Reset para permitir segunda captura
+                setTimeout(() => {
+                    this.hasScreenshotTaken = false;
+                }, 2000);
+            }
+        }
+        else {
+            cardOutline?.classList.remove('perfect-match');
+            corners?.forEach(corner => corner.classList.remove('perfect-match'));
+        }
+    }
+    updateGuidanceStatus(boxes) {
+        if (boxes.length === 0) {
+            this.statusMessage = "Posicione la identificación dentro del marco";
+            this.statusColor = "#ff6b6b";
+        }
+        else {
+            const bestBox = boxes.reduce((best, current) => current.score > best.score ? current : best);
+            const alignment = this.checkSideAlignment(bestBox);
+            const alignedSides = [alignment.top, alignment.right, alignment.bottom, alignment.left].filter(Boolean).length;
+            const allSidesAligned = this.areAllSidesAligned(alignment);
+            if (allSidesAligned) {
+                this.statusMessage = "Identificación perfectamente alineada. Mantenga inmóvil";
+                this.statusColor = "#00ff00";
+            }
+            else if (alignedSides > 0) {
+                this.statusMessage = `Alinee los lados restantes (${alignedSides}/4 lados correctos)`;
+                this.statusColor = "#ffb366";
+            }
+            else if (bestBox.w < 150) {
+                this.statusMessage = "Identificación detectada. Acerque al marco";
+                this.statusColor = "#ffb366";
+            }
+            else {
+                this.statusMessage = "Identificación detectada. Alinee con el marco";
+                this.statusColor = "#ffb366";
+            }
+        }
+    }
+    drawDetections(ctx, boxes) {
+        if (!this.videoRef)
+            return;
+        // Get video and container dimensions
+        const videoWidth = this.videoRef.videoWidth;
+        const videoHeight = this.videoRef.videoHeight;
+        const containerWidth = this.canvasRef.width;
+        const containerHeight = this.canvasRef.height;
+        if (videoWidth === 0 || videoHeight === 0)
+            return;
+        // Calculate video aspect ratio and container aspect ratio
+        const videoAspectRatio = videoWidth / videoHeight;
+        const containerAspectRatio = containerWidth / containerHeight;
+        // Determine how video fits in container (same logic as updateMaskDimensions)
+        let displayedVideoWidth, displayedVideoHeight;
+        let videoOffsetX = 0, videoOffsetY = 0;
+        if (videoAspectRatio > containerAspectRatio) {
+            // Video is wider - letterboxed (black bars top/bottom)
+            displayedVideoWidth = containerWidth;
+            displayedVideoHeight = containerWidth / videoAspectRatio;
+            videoOffsetY = (containerHeight - displayedVideoHeight) / 2;
+        }
+        else {
+            // Video is taller - pillarboxed (black bars left/right)
+            displayedVideoHeight = containerHeight;
+            displayedVideoWidth = containerHeight * videoAspectRatio;
+            videoOffsetX = (containerWidth - displayedVideoWidth) / 2;
+        }
+        // Scale factor from model coordinates (320x320) to displayed video area
+        const scaleX = displayedVideoWidth / this.INPUT_SIZE;
+        const scaleY = displayedVideoHeight / this.INPUT_SIZE;
+        boxes.forEach(det => {
+            // Convert model coordinates to displayed video coordinates
+            const x = det.x * scaleX + videoOffsetX;
+            const y = det.y * scaleY + videoOffsetY;
+            const w = det.w * scaleX;
+            const h = det.h * scaleY;
+            ctx.strokeStyle = "#32406C";
+            ctx.lineWidth = 2;
+            ctx.strokeRect(x, y, w, h);
+        });
+    }
+    takeScreenshot() {
+        if (!this.videoRef || !this.lastDetectedBox)
+            return;
+        // Activar animación
+        this.triggerCaptureAnimation();
+        // OPTIMIZATION: Reuse capture canvas for full frame
+        if (!this.captureCanvas || !this.captureCtx) {
+            this.initializeCanvasPool();
+        }
+        // Resize reused canvas for full frame
+        this.captureCanvas.width = this.videoRef.videoWidth;
+        this.captureCanvas.height = this.videoRef.videoHeight;
+        this.captureCtx.drawImage(this.videoRef, 0, 0, this.captureCanvas.width, this.captureCanvas.height);
+        // Calcular las coordenadas de recorte basadas en la detección
+        const scaleX = this.videoRef.videoWidth / this.INPUT_SIZE;
+        const scaleY = this.videoRef.videoHeight / this.INPUT_SIZE;
+        const cropX = Math.max(0, this.lastDetectedBox.x * scaleX);
+        const cropY = Math.max(0, this.lastDetectedBox.y * scaleY);
+        const cropWidth = Math.min(this.lastDetectedBox.w * scaleX, this.videoRef.videoWidth - cropX);
+        const cropHeight = Math.min(this.lastDetectedBox.h * scaleY, this.videoRef.videoHeight - cropY);
+        // OPTIMIZATION: Create temporary canvas only for cropped version
+        // (We reuse main capture canvas for full frame)
+        const croppedCanvas = document.createElement('canvas');
+        croppedCanvas.width = cropWidth;
+        croppedCanvas.height = cropHeight;
+        const croppedCtx = croppedCanvas.getContext('2d', { alpha: false });
+        // Recortar la identificación del frame completo
+        croppedCtx.drawImage(this.videoRef, cropX, cropY, cropWidth, cropHeight, // Área de origen
+        0, 0, cropWidth, cropHeight // Área de destino
+        );
+        if (this.captureStep === 'front') {
+            // Captura del frente usando canvas reutilizado
+            this.capturedFullFrame = this.captureCanvas.toDataURL('image/png');
+            this.capturedCroppedId = croppedCanvas.toDataURL('image/png');
+            this.captureStep = 'back';
+            this.statusMessage = "Voltee la identificación y muestre la parte trasera";
+            this.statusColor = "#007bff";
+            // Pausar detección durante la animación de giro
+            this.isDetectionPaused = true;
+            // Mostrar animación de giro después de la captura
+            setTimeout(() => {
+                this.showFlipAnimation = true;
+                setTimeout(() => {
+                    this.showFlipAnimation = false;
+                    // Reanudar detección después de que termine la animación
+                    this.isDetectionPaused = false;
+                }, 3000);
+            }, 800);
+            this.debugLog('📸 FRENTE capturado. Esperando trasera...');
+        }
+        else if (this.captureStep === 'back') {
+            // Captura de la trasera usando canvas reutilizado
+            this.capturedBackFullFrame = this.captureCanvas.toDataURL('image/png');
+            this.capturedBackCroppedId = croppedCanvas.toDataURL('image/png');
+            this.completeProcess(false);
+            this.debugLog('📸 TRASERA capturada. Proceso completado. Detector detenido. Imágenes emitidas.');
+        }
+    }
+    triggerCaptureAnimation() {
+        this.isCapturing = true;
+        // Agregar clase de animación al marco
+        const cardOutline = this.el.shadowRoot?.querySelector('.card-outline');
+        cardOutline?.classList.add('capturing');
+        // Limpiar animación después de que termine
+        setTimeout(() => {
+            this.isCapturing = false;
+            cardOutline?.classList.remove('capturing');
+        }, 600);
+    }
+    stopDetection() {
+        if (this.animationId) {
+            cancelAnimationFrame(this.animationId);
+            this.animationId = undefined;
+        }
+        // Limpiar canvas para eliminar cualquier detección visual residual
+        if (this.canvasRef) {
+            const ctx = this.canvasRef.getContext("2d");
+            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+        }
+        this.debugLog('🛑 Detector de identificación detenido');
+    }
+    resetDetection() {
+        this.bestScore = 0;
+        this.startTime = Date.now();
+        this.statusMessage = "Sistema reiniciado. Posicione la identificación";
+        this.statusColor = "#aaa";
+        this.hasScreenshotTaken = false;
+        this.capturedFullFrame = null;
+        this.capturedCroppedId = null;
+        this.capturedBackFullFrame = null;
+        this.capturedBackCroppedId = null;
+        this.captureStep = 'front';
+        this.isCapturing = false;
+        this.showFlipAnimation = false;
+        this.showSuccessAnimation = false;
+        this.isDetectionPaused = false;
+        this.isLoading = false;
+        this.lastDetectedBox = undefined;
+        this.isModelPreloaded = false;
+        // Reset performance counters
+        this.frameSkipCounter = 0;
+        this.consecutiveFailures = 0;
+        this.lastInferenceTime = 0;
+        if (this.canvasRef) {
+            const ctx = this.canvasRef.getContext("2d");
+            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+        }
+        // Reiniciar el detector si estaba funcionando
+        if (this.isVideoActive && this.session) {
+            this.detectFrame();
+        }
+    }
+    completeProcess(skippedBack = false) {
+        this.captureStep = 'completed';
+        this.statusMessage = skippedBack ?
+            "Proceso completado (solo frente capturado)" :
+            "Proceso de captura completado exitosamente";
+        this.statusColor = "#28a745";
+        // Detener el detector
+        this.stopDetection();
+        // Emitir evento con las imágenes capturadas
+        const capturedImages = {
+            front: {
+                fullFrame: this.capturedFullFrame,
+                cropped: this.capturedCroppedId
+            },
+            back: {
+                fullFrame: this.capturedBackFullFrame,
+                cropped: this.capturedBackCroppedId
+            },
+            timestamp: new Date().toISOString(),
+            metadata: {
+                totalImages: skippedBack ? 2 : 4,
+                processCompleted: true,
+                backCaptureSkipped: skippedBack
+            }
+        };
+        this.captureCompleted.emit(capturedImages);
+        // Mostrar animación de éxito después de la captura
+        setTimeout(() => {
+            this.showSuccessAnimation = true;
+            setTimeout(() => {
+                this.showSuccessAnimation = false;
+            }, 3000);
+        }, 800);
+    }
+    exitSession() {
+        if (this.videoStream) {
+            this.videoStream.getTracks().forEach(track => track.stop());
+            this.videoStream = undefined;
+            this.isVideoActive = false;
+            this.statusMessage = "Sesión finalizada.";
+            this.statusColor = "#aaa";
+        }
+        this.isLoading = false;
+        // Limpiar canvas al finalizar sesión
+        if (this.canvasRef) {
+            const ctx = this.canvasRef.getContext("2d");
+            ctx.clearRect(0, 0, this.canvasRef.width, this.canvasRef.height);
+        }
+        this.cleanup();
+    }
+    render() {
+        return (h("div", { key: 'b63a5966ee08d4de7b5d8a10dbf248150e8620ec', class: "detector-container" }, h("div", { key: '1c62d540a1802a758b90a543edfdc364123ae950', class: "video-container" }, h("video", { key: '18e066e0005c3b287983ebb29c9e4aa147eaaf8d', ref: el => this.videoRef = el, autoplay: true, muted: true, playsinline: true, class: this.shouldMirrorVideo ? 'mirror' : '', style: { display: this.isVideoActive ? 'block' : 'none' } }), h("canvas", { key: '43cd238e38a5a2ff9c140800ac686580a7ca33b9', ref: el => this.canvasRef = el, class: this.shouldMirrorVideo ? 'mirror' : '' }), this.isMaskReady && (h("div", { key: 'f43db67b9d1ef47264092694c3ab8afa9925e258', class: "overlay-mask" }, h("div", { key: 'ac60d94edc4cfa6ccf91ba6e04d2be6e4368be97', class: "card-outline" }, h("div", { key: 'de6aca9bbfe778890adf4c69e8525a114c37f6d4', class: "side side-top" }), h("div", { key: '7ce7b1e2215b01ea5d714b8ecc988361e384b6f7', class: "side side-right" }), h("div", { key: 'b79a68f68facb42ca139d6a2bc8e1e6d7133872d', class: "side side-bottom" }), h("div", { key: '81d90c4a08cfc2267cec195a3b342c87bb1d07d0', class: "side side-left" }), h("div", { key: 'c93c83abb8e17a5cb9c1bd53b2e1239ef50c7bf4', class: "corner corner-tl" }), h("div", { key: '81ca7cf2aab7026e851bd226843a6db5807315d5', class: "corner corner-tr" }), h("div", { key: 'c451fe226ac15023ee9799443060f1da620cb3b3', class: "corner corner-bl" }), h("div", { key: '7c3e2b2a21bd37144fe6b4d5df67df625dc12103', class: "corner corner-br" }), !this.showFlipAnimation && !this.showSuccessAnimation && (h("div", { key: '74ab171b64bdf0e1269845b4fcd9bf8e2caf891d', class: "guide-text" }, this.statusMessage))), this.captureStep === 'back' && !this.showFlipAnimation && !this.showSuccessAnimation && (h("button", { key: '2b2b9387ce8b023acf0d65c7f7b3480211f7cb2d', class: "skip-button", onClick: () => this.skipBackCapture(), type: "button" }, "Saltar reverso")))), this.isCapturing && (h("div", { key: 'eabd88499f52098f79e434afcce73acb2727c411', class: "capture-animation" })), this.showFlipAnimation && (h("div", { key: '9affe6040a39260747db98db2b68a103fb719fbb', class: "flip-animation" }, h("div", { key: '8b25f3688a16f4b070664237a093122a6720edfb', class: "id-card-icon" }), h("div", { key: '805b11cfb4d06a25e02370b06f6cf15f0f0cf6b5', class: "flip-text" }, "\u00A1Voltea tu identificaci\u00F3n!"))), this.showSuccessAnimation && (h("div", { key: 'cba337b6fef8b919425566c0c9c5de797d42c4c8', class: "success-animation" }, h("div", { key: '4a88df3f9285757b489b030ba985d720a8a3badf', class: "check-icon" }), h("div", { key: 'a0bdd89c2c6274330ba66a6b6bba86ab6c725979', class: "success-text" }, "\u00A1Proceso completado!"))), this.isLoading && (h("div", { key: '564fc1333b0fb69102e26ac1da4e77786a9bc7a3', class: "loading-overlay" }, h("div", { key: '283e4a6315a39b26203e19a13f35389bc1870a0f', class: "loading-spinner" }), h("div", { key: '7e4f00a1fcee1bbf29d74c8be35a72aba2c1041a', class: "loading-text" }, this.statusMessage))), h("div", { key: '6cbe1fea1c4a7d3cb25cd34ee04becb5fa538dfd', class: "watermark" }, h("img", { key: '1bd4157b7f74753570ddf48682acf419a6de03ea', src: "https://storage.googleapis.com/jaak-static/commons/powered-by-jaak.png", alt: "Powered by Jaak" })))));
+    }
+    static get is() { return "jaak-stamps"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["my-component.css"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["my-component.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "debug": {
+                "type": "boolean",
+                "attribute": "debug",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "alignmentTolerance": {
+                "type": "number",
+                "attribute": "alignment-tolerance",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "10"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isVideoActive": {},
+            "statusMessage": {},
+            "statusColor": {},
+            "bestScore": {},
+            "capturedFullFrame": {},
+            "capturedCroppedId": {},
+            "capturedBackFullFrame": {},
+            "capturedBackCroppedId": {},
+            "captureStep": {},
+            "isCapturing": {},
+            "showFlipAnimation": {},
+            "showSuccessAnimation": {},
+            "shouldMirrorVideo": {},
+            "sideAlignment": {},
+            "isDetectionPaused": {},
+            "isLoading": {},
+            "isModelPreloaded": {},
+            "isMaskReady": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "captureCompleted",
+                "name": "captureCompleted",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "isReady",
+                "name": "isReady",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "getCapturedImages": {
+                "complexType": {
+                    "signature": "() => Promise<{ front: { fullFrame: string; cropped: string; }; back: { fullFrame: string; cropped: string; }; metadata: { hasBackCapture: boolean; totalImages: number; }; }>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ front: { fullFrame: string; cropped: string; }; back: { fullFrame: string; cropped: string; }; metadata: { hasBackCapture: boolean; totalImages: number; }; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "isProcessCompleted": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "startCapture": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "stopCapture": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "resetCapture": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getStatus": {
+                "complexType": {
+                    "signature": "() => Promise<{ isVideoActive: boolean; captureStep: \"front\" | \"back\" | \"completed\"; statusMessage: string; hasImages: boolean; isProcessCompleted: boolean; isModelPreloaded: boolean; }>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ isVideoActive: boolean; captureStep: \"front\" | \"back\" | \"completed\"; statusMessage: string; hasImages: boolean; isProcessCompleted: boolean; isModelPreloaded: boolean; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "preloadModel": {
+                "complexType": {
+                    "signature": "() => Promise<{ success: boolean; message: string; error?: undefined; } | { success: boolean; error: any; message?: undefined; }>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ success: boolean; message: string; error?: undefined; } | { success: boolean; error: any; message?: undefined; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "skipBackCapture": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+}
+//# sourceMappingURL=my-component.js.map