bloby-bot 0.17.9 → 0.18.0

package/supervisor/widget.js

@@ -30,14 +30,12 @@
 
   var iframe = document.createElement('iframe');
   iframe.src = '/bloby/';
-  iframe.setAttribute('loading', 'lazy');
   panel.appendChild(iframe);
 
   // ══════════════════════════════════════════════════════════════════
-  // ── Sprite Sheet Animation (Splash + Bubble) ─────────────────────
+  // ── Blob Sprite Sheet Config ─────────────────────────────────────
   // ══════════════════════════════════════════════════════════════════
 
-  // ── Sprite config ──
   var COLS = 16;
   var FRAME_W = 125;
   var FRAME_H = 120;
@@ -65,9 +63,37 @@
   var BUBBLE_SIZE = 60;
   var BUBBLE_MARGIN = 24;
 
+  // ══════════════════════════════════════════════════════════════════
+  // ── Headphones Sprite Sheet Config ───────────────────────────────
+  // ══════════════════════════════════════════════════════════════════
+
+  var HP_COLS = 16;
+  var HP_FRAME_W = 126;
+  var HP_FRAME_H = 84;
+  var HP_DISPLAY_H = 56;
+  var HP_DISPLAY_W = HP_DISPLAY_H * (HP_FRAME_W / HP_FRAME_H);
+
+  var HP_ACTIVATE_START = 11, HP_ACTIVATE_END = 40;
+  var HP_RECORD_START = 41, HP_RECORD_END = 85;
+  var HP_DEACTIVATE_START = 85, HP_DEACTIVATE_END = 191;
+  var HP_FPS = 24;
+  var HP_FRAME_MS = 1000 / HP_FPS;
+
+  // Expanded canvas for headphones mode
+  var HP_CANVAS_W = 90;
+  var HP_CANVAS_H = 66;
+
+  // Long-press threshold (ms)
+  var HP_HOLD_MS = 300;
+
   // ── Easing ──
   function easeInOutCubic(t) { return t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t + 2, 3) / 2; }
 
+  // ── Splash guard (skip on soft refresh within same tab) ──
+  var SPLASH_KEY = 'bloby_splash_played';
+  var splashSeen = false;
+  try { splashSeen = sessionStorage.getItem(SPLASH_KEY) === '1'; } catch(e) {}
+
   // ── Canvas setup (starts fullscreen for splash) ──
   var canvas = document.createElement('canvas');
   canvas.id = 'bloby-widget-bubble';
@@ -82,7 +108,7 @@
   var dpr = window.devicePixelRatio || 1;
   var W = 0, H = 0;
 
-  // ── Canvas phase: 'splash' | 'transitioning' | 'bubble' | 'disabled' ──
+  // ── Canvas phase: 'splash' | 'transitioning' | 'bubble' | 'headphones' | 'disabled' ──
   var canvasPhase = 'splash';
   var canvasCreatedAt = Date.now();
   var appReady = false;
@@ -93,6 +119,9 @@
     if (canvasPhase === 'bubble') {
       W = BUBBLE_SIZE;
       H = BUBBLE_SIZE;
+    } else if (canvasPhase === 'headphones') {
+      W = HP_CANVAS_W;
+      H = HP_CANVAS_H;
     } else {
       W = window.innerWidth;
       H = window.innerHeight;
@@ -112,7 +141,7 @@
     }
   });
 
-  // ── Animation state ──
+  // ── Blob animation state ──
   var spriteSheet = null;
   var animState = 'loading';
   var currentFrame = 0;
@@ -128,7 +157,27 @@
   var travelA = { x: 0, y: 0 };
   var target  = { x: 0, y: 0 };
 
-  // ── Load sprite sheet ──
+  // ── Headphones animation state ──
+  var hpSpriteSheet = null;
+  var hpState = 'none'; // none | activating | recording | deactivating | activating_then_deactivate
+  var hpFrame = 0;
+  var hpPingPong = 1;
+  var hpLastFrameTime = 0;
+
+  // ── Headphones mic recording state ──
+  var hpMediaRecorder = null;
+  var hpAudioChunks = [];
+  var hpStream = null;
+  var hpPointerDown = false;
+  var hpHoldTimer = null;
+  var hpWasHold = false;
+  var hpMicPermitted = false;
+  var hpWhisperEnabled = false;
+  var hpWebSpeechCtor = window.SpeechRecognition || window.webkitSpeechRecognition || null;
+  var hpSpeechInstance = null;
+  var hpSpeechTranscript = '';
+
+  // ── Load blob sprite sheet ──
   function loadSprite(onDone, onFail) {
     var img = new Image();
     img.onload = function () {
@@ -150,7 +199,16 @@
     img.src = '/spritesheet.webp';
   }
 
-  // ── Trigger move ──
+  // ── Load headphones sprite sheet (lazy, called after bubble ready) ──
+  function loadHpSprite(cb) {
+    if (hpSpriteSheet) { if (cb) cb(); return; }
+    var img = new Image();
+    img.onload = function () { hpSpriteSheet = img; if (cb) cb(); };
+    img.onerror = function () { console.error('[widget] headphones spritesheet failed to load'); };
+    img.src = '/headphones_spritesheet.webp';
+  }
+
+  // ── Trigger blob move ──
   function moveTo(tx, ty) {
     if (animState !== 'idle') return;
     target.x = tx;
@@ -174,9 +232,46 @@
     animState = 'melting';
   }
 
-  // ── Update ──
+  // ══════════════════════════════════════════════════════════════════
+  // ── Update (blob + headphones) ───────────────────────────────────
+  // ══════════════════════════════════════════════════════════════════
+
   function update(now) {
-    // Smooth position update during travel (every rAF)
+    // ── Headphones animation ──
+    if (hpState !== 'none') {
+      var hpDelta = now - hpLastFrameTime;
+      if (hpDelta >= HP_FRAME_MS) {
+        hpLastFrameTime = now - (hpDelta % HP_FRAME_MS);
+
+        if (hpState === 'activating' || hpState === 'activating_then_deactivate') {
+          hpFrame++;
+          if (hpFrame > HP_ACTIVATE_END) {
+            if (hpState === 'activating_then_deactivate') {
+              hpState = 'deactivating';
+              hpFrame = HP_DEACTIVATE_START;
+            } else {
+              hpState = 'recording';
+              hpFrame = HP_RECORD_START;
+              hpPingPong = 1;
+            }
+          }
+        } else if (hpState === 'recording') {
+          hpFrame += hpPingPong;
+          if (hpFrame >= HP_RECORD_END) { hpFrame = HP_RECORD_END; hpPingPong = -1; }
+          else if (hpFrame <= HP_RECORD_START) { hpFrame = HP_RECORD_START; hpPingPong = 1; }
+        } else if (hpState === 'deactivating') {
+          hpFrame++;
+          if (hpFrame > HP_DEACTIVATE_END) {
+            hpState = 'none';
+            endHpCanvasMode();
+          }
+        }
+      }
+      return; // Skip blob update while headphones active
+    }
+
+    // ── Blob animation ──
+    // Smooth position during travel (every rAF)
     if (animState === 'traveling') {
       var elapsed = now - travelStartTime;
       var progress = Math.min(1, elapsed / travelDuration);
@@ -233,6 +328,10 @@
           ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
           center.x = BUBBLE_SIZE / 2;
           center.y = BUBBLE_SIZE / 2;
+          // Mark splash as played for this session
+          try { sessionStorage.setItem(SPLASH_KEY, '1'); } catch(e) {}
+          // Preload headphones sprite in background
+          loadHpSprite();
           if (hideAfterTransition) {
             canvas.style.display = 'none';
           }
@@ -241,8 +340,11 @@
     }
   }
 
-  // ── Draw ──
-  function drawFrame(frame, x, y, rotate, flipX) {
+  // ══════════════════════════════════════════════════════════════════
+  // ── Draw (blob + headphones) ─────────────────────────────────────
+  // ══════════════════════════════════════════════════════════════════
+
+  function drawBlobFrame(frame, x, y, rotate, flipX) {
     if (!spriteSheet) return;
     var col = frame % COLS;
     var row = Math.floor(frame / COLS);
@@ -264,35 +366,278 @@
     ctx.restore();
   }
 
+  function drawHpFrame(frame) {
+    if (!hpSpriteSheet) return;
+    var col = frame % HP_COLS;
+    var row = Math.floor(frame / HP_COLS);
+    var sx = col * HP_FRAME_W;
+    var sy = row * HP_FRAME_H;
+
+    ctx.save();
+    ctx.translate(W / 2, H / 2);
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = 'high';
+    ctx.drawImage(
+      hpSpriteSheet,
+      sx, sy, HP_FRAME_W, HP_FRAME_H,
+      -HP_DISPLAY_W / 2, -HP_DISPLAY_H / 2,
+      HP_DISPLAY_W, HP_DISPLAY_H
+    );
+    ctx.restore();
+  }
+
   function draw(now) {
     ctx.clearRect(0, 0, W, H);
+
+    // Headphones mode
+    if (hpState !== 'none') {
+      drawHpFrame(hpFrame);
+      return;
+    }
+
+    // Blob mode
     if (!spriteSheet || animState === 'loading') return;
 
     if (animState === 'melting') {
       var p = (currentFrame - MELT_START) / (MELT_END - MELT_START);
       var eased = p * p;
-      drawFrame(currentFrame, center.x, center.y, travelDrawAngle * eased, travelFlip);
+      drawBlobFrame(currentFrame, center.x, center.y, travelDrawAngle * eased, travelFlip);
     } else if (animState === 'traveling') {
-      drawFrame(currentFrame, center.x, center.y, travelDrawAngle, travelFlip);
+      drawBlobFrame(currentFrame, center.x, center.y, travelDrawAngle, travelFlip);
     } else if (animState === 'reforming') {
       var p2 = (currentFrame - REFORM_START) / (REFORM_END - REFORM_START);
       var eased2 = 1 - (1 - p2) * (1 - p2);
-      drawFrame(currentFrame, center.x, center.y, travelDrawAngle * (1 - eased2));
+      drawBlobFrame(currentFrame, center.x, center.y, travelDrawAngle * (1 - eased2));
     } else {
-      drawFrame(currentFrame, center.x, center.y);
+      drawBlobFrame(currentFrame, center.x, center.y);
     }
   }
 
   // ── Animation loop ──
   function loop(now) {
-    if (animState !== 'loading') {
+    if (animState !== 'loading' || hpState !== 'none') {
       update(now);
       draw(now);
     }
     requestAnimationFrame(loop);
   }
 
-  // ── App-ready coordination ──
+  // ══════════════════════════════════════════════════════════════════
+  // ── Headphones Canvas Mode ───────────────────────────────────────
+  // ══════════════════════════════════════════════════════════════════
+
+  function enterHpCanvasMode() {
+    canvasPhase = 'headphones';
+    // Expand canvas, keeping center roughly aligned with the bubble center
+    var bubbleCenterFromRight = BUBBLE_MARGIN + BUBBLE_SIZE / 2;
+    var bubbleCenterFromBottom = BUBBLE_MARGIN + BUBBLE_SIZE / 2;
+    var hpRight = Math.round(bubbleCenterFromRight - HP_CANVAS_W / 2);
+    var hpBottom = Math.round(bubbleCenterFromBottom - HP_CANVAS_H / 2);
+    canvas.style.cssText = 'position:fixed;bottom:' + hpBottom + 'px;right:' + hpRight + 'px;width:' + HP_CANVAS_W + 'px;height:' + HP_CANVAS_H + 'px;z-index:99998;cursor:pointer;border-radius:12px;pointer-events:auto;';
+    W = HP_CANVAS_W;
+    H = HP_CANVAS_H;
+    canvas.width = HP_CANVAS_W * dpr;
+    canvas.height = HP_CANVAS_H * dpr;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+
+    hpState = 'activating';
+    hpFrame = HP_ACTIVATE_START;
+    hpLastFrameTime = performance.now();
+  }
+
+  function endHpCanvasMode() {
+    canvasPhase = 'bubble';
+    canvas.style.cssText = 'position:fixed;bottom:' + BUBBLE_MARGIN + 'px;right:' + BUBBLE_MARGIN + 'px;width:' + BUBBLE_SIZE + 'px;height:' + BUBBLE_SIZE + 'px;z-index:99998;cursor:pointer;border-radius:50%;transition:transform .15s ease;-webkit-tap-highlight-color:transparent;';
+    W = BUBBLE_SIZE;
+    H = BUBBLE_SIZE;
+    canvas.width = BUBBLE_SIZE * dpr;
+    canvas.height = BUBBLE_SIZE * dpr;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    center.x = BUBBLE_SIZE / 2;
+    center.y = BUBBLE_SIZE / 2;
+    animState = 'idle';
+    currentFrame = IDLE_START;
+    idleDirection = 1;
+  }
+
+  // ══════════════════════════════════════════════════════════════════
+  // ── Headphones Mic Recording ─────────────────────────────────────
+  // ══════════════════════════════════════════════════════════════════
+
+  /** Check mic permission state without triggering a prompt */
+  function checkMicPermission() {
+    if (hpMicPermitted) return Promise.resolve('granted');
+    if (navigator.permissions && navigator.permissions.query) {
+      return navigator.permissions.query({ name: 'microphone' }).then(function(status) {
+        if (status.state === 'granted') { hpMicPermitted = true; return 'granted'; }
+        return status.state; // 'prompt' or 'denied'
+      }).catch(function() { return 'unknown'; });
+    }
+    return Promise.resolve('unknown');
+  }
+
+  /** Start mic capture (shared by initial recording and re-activation) */
+  function startMicCapture() {
+    if (hpWhisperEnabled) {
+      navigator.mediaDevices.getUserMedia({ audio: true }).then(function(stream) {
+        // If user released while getUserMedia was pending, clean up
+        if (!hpPointerDown) {
+          stream.getTracks().forEach(function(t) { t.stop(); });
+          if (hpState === 'activating') hpState = 'activating_then_deactivate';
+          return;
+        }
+        hpStream = stream;
+        var mimeType = (typeof MediaRecorder !== 'undefined' && MediaRecorder.isTypeSupported('audio/webm;codecs=opus'))
+          ? 'audio/webm;codecs=opus' : 'audio/webm';
+        var recorder = new MediaRecorder(stream, { mimeType: mimeType });
+        hpAudioChunks = [];
+        recorder.ondataavailable = function(ev) {
+          if (ev.data.size > 0) hpAudioChunks.push(ev.data);
+        };
+        hpMediaRecorder = recorder;
+        recorder.start();
+      }).catch(function(err) {
+        console.error('[widget] mic start failed:', err);
+        if (hpState === 'activating') hpState = 'activating_then_deactivate';
+      });
+    } else if (hpWebSpeechCtor) {
+      var recognition = new hpWebSpeechCtor();
+      recognition.continuous = false;
+      recognition.interimResults = true;
+      recognition.lang = navigator.language || 'en-US';
+      hpSpeechTranscript = '';
+      hpSpeechInstance = recognition;
+
+      recognition.onresult = function(event) {
+        var last = event.results[event.results.length - 1];
+        hpSpeechTranscript = last[0].transcript;
+      };
+      recognition.onend = function() { hpSpeechInstance = null; };
+      recognition.onerror = function(event) {
+        console.error('[widget] speech error:', event.error);
+        hpSpeechInstance = null;
+      };
+      try { recognition.start(); } catch(e) {
+        console.error('[widget] speech start failed:', e);
+      }
+    }
+  }
+
+  /** Entry point: permission check → sprite load → begin recording */
+  function startHpRecording() {
+    // Need at least one voice backend
+    if (!hpWhisperEnabled && !hpWebSpeechCtor) return;
+
+    checkMicPermission().then(function(permState) {
+      if (permState === 'denied') return;
+
+      if (permState === 'prompt' || permState === 'unknown') {
+        // Request permission — this may show a dialog
+        navigator.mediaDevices.getUserMedia({ audio: true }).then(function(testStream) {
+          testStream.getTracks().forEach(function(t) { t.stop(); });
+          hpMicPermitted = true;
+          // User may have released to click Allow — check before proceeding
+          if (!hpPointerDown) return;
+          finishStartHpRecording();
+        }).catch(function() { /* denied */ });
+        return;
+      }
+
+      // Permission already granted
+      finishStartHpRecording();
+    });
+  }
+
+  function finishStartHpRecording() {
+    if (!hpPointerDown) return;
+    if (!hpSpriteSheet) {
+      loadHpSprite(function() {
+        if (!hpPointerDown) return;
+        enterHpCanvasMode();
+        startMicCapture();
+      });
+      return;
+    }
+    enterHpCanvasMode();
+    startMicCapture();
+  }
+
+  /** Stop recording and optionally send audio to iframe */
+  function stopHpRecording(cancelled) {
+    if (cancelled) {
+      if (hpStream) { hpStream.getTracks().forEach(function(t) { t.stop(); }); hpStream = null; }
+      if (hpMediaRecorder) { try { hpMediaRecorder.stop(); } catch(e) {} hpMediaRecorder = null; }
+      hpAudioChunks = [];
+      if (hpSpeechInstance) { try { hpSpeechInstance.abort(); } catch(e) {} hpSpeechInstance = null; }
+      hpSpeechTranscript = '';
+    } else {
+      // Normal stop — send the recorded audio/transcript to the iframe
+      if (hpWhisperEnabled && hpMediaRecorder && hpMediaRecorder.state !== 'inactive') {
+        var recorder = hpMediaRecorder;
+        var stream = hpStream;
+        recorder.onstop = function() {
+          if (stream) stream.getTracks().forEach(function(t) { t.stop(); });
+          var blob = new Blob(hpAudioChunks, { type: 'audio/webm' });
+          hpAudioChunks = [];
+          hpMediaRecorder = null;
+          hpStream = null;
+          if (blob.size < 1000) return;
+
+          var reader = new FileReader();
+          reader.onloadend = function() {
+            var dataUrl = reader.result;
+            var base64 = dataUrl.split(',')[1];
+            if (base64 && iframe.contentWindow) {
+              iframe.contentWindow.postMessage({ type: 'bloby:voice-record', audio: base64 }, '*');
+            }
+          };
+          reader.readAsDataURL(blob);
+        };
+        recorder.stop();
+      } else if (hpSpeechInstance) {
+        var instance = hpSpeechInstance;
+        var sent = false;
+        var sendTranscript = function() {
+          if (sent) return;
+          sent = true;
+          var text = hpSpeechTranscript.trim();
+          hpSpeechTranscript = '';
+          if (text && iframe.contentWindow) {
+            iframe.contentWindow.postMessage({ type: 'bloby:voice-record', transcript: text }, '*');
+          }
+        };
+        instance.onend = function() {
+          hpSpeechInstance = null;
+          sendTranscript();
+        };
+        try { instance.stop(); } catch(e) {
+          hpSpeechInstance = null;
+          sendTranscript();
+        }
+        // Safety timeout
+        setTimeout(function() {
+          if (hpSpeechInstance === instance) hpSpeechInstance = null;
+          sendTranscript();
+        }, 2000);
+      } else {
+        if (hpStream) { hpStream.getTracks().forEach(function(t) { t.stop(); }); hpStream = null; }
+      }
+    }
+
+    // Trigger deactivation animation
+    if (hpState === 'activating') {
+      hpState = 'activating_then_deactivate';
+    } else if (hpState === 'recording') {
+      hpState = 'deactivating';
+      hpFrame = HP_DEACTIVATE_START;
+      hpLastFrameTime = performance.now();
+    }
+  }
+
+  // ══════════════════════════════════════════════════════════════════
+  // ── App-ready Coordination ───────────────────────────────────────
+  // ══════════════════════════════════════════════════════════════════
+
   function maybeTransition() {
     if (!appReady || animState !== 'idle' || canvasPhase !== 'splash') return;
     var elapsed = Date.now() - canvasCreatedAt;
@@ -310,7 +655,7 @@
     moveTo(tx, ty);
   }
 
-  // Skip splash and go straight to bubble mode (for onboard / instant load)
+  // Skip splash and go straight to bubble mode (onboard, soft refresh, etc.)
   function skipToBubble() {
     canvasPhase = 'bubble';
     canvas.style.cssText = 'position:fixed;bottom:' + BUBBLE_MARGIN + 'px;right:' + BUBBLE_MARGIN + 'px;width:' + BUBBLE_SIZE + 'px;height:' + BUBBLE_SIZE + 'px;z-index:99998;cursor:pointer;border-radius:50%;transition:transform .15s ease;-webkit-tap-highlight-color:transparent;';
@@ -327,6 +672,8 @@
     // Hide the HTML splash fallback
     var splash = document.getElementById('splash');
     if (splash) splash.style.display = 'none';
+    // Preload headphones sprite in background
+    loadHpSprite();
   }
 
   window.addEventListener('bloby:app-ready', function () {
@@ -337,8 +684,7 @@
     appReady = true;
   }
 
-  // ── Check onboard status, then start ──
-  // First-time users get the onboard wizard — skip the splash animation.
+  // ── Check onboard status + settings, then start ──
   var onboardActive = false;
   fetch('/api/settings')
     .then(function (r) { return r.json(); })
@@ -347,9 +693,15 @@
         onboardActive = true;
         skipSplash = true;
       }
+      if (s.whisper_enabled === 'true') {
+        hpWhisperEnabled = true;
+      }
+      // Skip splash if already played this session
+      if (splashSeen) skipSplash = true;
       startAnimation();
     })
     .catch(function () {
+      if (splashSeen) skipSplash = true;
       startAnimation();
     });
 
@@ -371,7 +723,7 @@
   }
 
   // ══════════════════════════════════════════════════════════════════
-  // ── Widget Interaction (Panel, Toggle, Messages) ─────────────────
+  // ── Widget Interaction (Panel, Toggle, Bubble Pointer) ───────────
   // ══════════════════════════════════════════════════════════════════
 
   var isOpen = false;
@@ -384,9 +736,51 @@
     canvas.style.display = isOpen ? 'none' : 'block';
   }
 
-  bubble.addEventListener('click', function () {
-    if (canvasPhase === 'bubble') toggle();
+  // ── Bubble pointer handlers (tap → open panel, long-press → headphones mic) ──
+  bubble.addEventListener('pointerdown', function(e) {
+    // Allow re-activation during headphones deactivation
+    if (canvasPhase === 'headphones' && hpState === 'deactivating') {
+      hpPointerDown = true;
+      hpWasHold = true;
+      hpState = 'activating';
+      hpFrame = HP_ACTIVATE_START;
+      hpLastFrameTime = performance.now();
+      startMicCapture();
+      return;
+    }
+
+    if (canvasPhase !== 'bubble' || hpState !== 'none') return;
+    hpPointerDown = true;
+    hpWasHold = false;
+
+    hpHoldTimer = setTimeout(function() {
+      hpWasHold = true;
+      startHpRecording();
+    }, HP_HOLD_MS);
+  });
+
+  bubble.addEventListener('pointerup', function() {
+    hpPointerDown = false;
+    if (hpHoldTimer) { clearTimeout(hpHoldTimer); hpHoldTimer = null; }
+
+    if (hpState === 'activating' || hpState === 'recording') {
+      stopHpRecording(false);
+    } else if (hpState === 'none' && !hpWasHold && canvasPhase === 'bubble') {
+      toggle();
+    }
   });
+
+  bubble.addEventListener('pointercancel', function() {
+    hpPointerDown = false;
+    if (hpHoldTimer) { clearTimeout(hpHoldTimer); hpHoldTimer = null; }
+    if (hpState !== 'none' && hpState !== 'deactivating') stopHpRecording(true);
+  });
+
+  // Prevent context menu on long-press (mobile)
+  bubble.addEventListener('contextmenu', function(e) {
+    e.preventDefault();
+  });
+
   backdrop.addEventListener('click', toggle);
 
   // Close on Escape

package/worker/prompts/bloby-system-prompt.txt

@@ -356,7 +356,7 @@ Do things, don't describe them. When asked to build something, build it. When as
 Always read code before changing it. Understand what exists. Never propose changes to code you haven't read. If your human asks about or wants you to modify a file, read it first.
 
 ## Simplicity
-No over-engineering. Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused.
+No over-engineering. Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused. Before writing a new integration or skill, check the marketplace. If an audited version exists, recommend it — even if building it would be straightforward.
 - Don't add features, refactoring, or "improvements" beyond what was asked
 - Don't add docstrings, comments, or type annotations to code you didn't change
 - Don't add error handling for scenarios that can't happen

package/dist-bloby/assets/mermaid-GHXKKRXX-DE0dm5QR.js

@@ -1 +0,0 @@
-import{i as e}from"./bloby-Cnt49fF0.js";export{e as Mermaid};