arcane-os 0.45.0 → 0.47.0

package/runtime/arcane/components/speech.html

@@ -191,6 +191,7 @@
         }
     );
     const aiModuleImport = import('../modules/AI.js');
+    const providerRuntimeImport = import('../modules/AIProviderRuntime.js');
     const {
         requestAIRuntimeIntent,
         subscribeAIRuntimeState
@@ -200,6 +201,8 @@
         formatAIRuntimeProgress
     } = await import('../modules/ComponentContracts.js');
     const {getBrowserDeviceClass} = await browserDeviceImport;
+    const {getAIProviderRuntime} = await providerRuntimeImport;
+    const providerRuntime = getAIProviderRuntime();
 
     const host = this;
     const deviceClass = getBrowserDeviceClass();
@@ -237,6 +240,7 @@
     let microphonePermissionStatus = null;
     let microphonePermissionListener = null;
     let captureSession = null;
+    let nativeCaptureSession = null;
     let recordingRequested = false;
     let recordingGeneration = 0;
     let transcriptionGeneration = 0;
@@ -362,8 +366,8 @@
     host.setMuted = setMuted;
     host.availability = {
         microphone: transcriptionEnabled && Boolean(
-            navigator.mediaDevices?.getUserMedia
-            && globalThis.MediaRecorder
+            (navigator.mediaDevices?.getUserMedia && globalThis.MediaRecorder)
+            || globalThis.SpeechRecognition || globalThis.webkitSpeechRecognition
         ),
         stt: false,
         tts: false
@@ -626,24 +630,25 @@
         }
         const transcriptionReady = sttRole.state === 'ready';
         const microphoneReady = host.availability.microphone
-            && is.function(globalThis.MediaRecorder)
-            && is.function(navigator.mediaDevices?.getUserMedia);
+            && (providerRuntime.supportsTranscriptionCapture()
+                || (is.function(globalThis.MediaRecorder)
+                    && is.function(navigator.mediaDevices?.getUserMedia)));
         const activationVisible = sttActivationController.visible;
         recordButton.hidden = activationVisible;
         recordButton.disabled = !transcriptionReady
             || !microphoneReady
-            || sttRole.busy
+            || (sttRole.busy && !nativeCaptureSession)
             || transcriptionActive
             || destroyed;
         stopButton.disabled = destroyed
             || !transcriptionReady
-            || sttRole.busy
-            || captureSession?.recorder.state !== 'recording';
+            || (sttRole.busy && !nativeCaptureSession)
+            || (!nativeCaptureSession && captureSession?.recorder.state !== 'recording');
         recordButton.title = transcriptionButtonTitle();
         recordButton.setAttribute('aria-label', recordButton.title);
         recordButton.setAttribute(
             'aria-pressed',
-            String(recordingRequested || Boolean(captureSession))
+            String(recordingRequested || Boolean(captureSession) || Boolean(nativeCaptureSession))
         );
         sttActivationButton.hidden = !activationVisible;
         sttActivationButton.disabled = destroyed
@@ -1288,21 +1293,23 @@
                 }
             }
         );
-        transcriptionOperationId = null;
+        if (transcriptionOperationId === operationId) transcriptionOperationId = null;
         return accepted;
     }
 
     async function record() {
+        const liveCapture = providerRuntime.supportsTranscriptionCapture();
         if (
             !transcriptionEnabled
             || destroyed
             || sttRole.state !== 'ready'
             || sttRole.busy
             || !host.availability.microphone
-            || !is.function(globalThis.MediaRecorder)
-            || !is.function(navigator.mediaDevices?.getUserMedia)
+            || (!liveCapture && (!is.function(globalThis.MediaRecorder)
+                || !is.function(navigator.mediaDevices?.getUserMedia)))
             || recordingRequested
             || captureSession
+            || nativeCaptureSession
             || transcriptionActive
         ) {
             resetRecordPress();
@@ -1322,6 +1329,8 @@
         renderControls();
         renderStatus();
 
+        if (liveCapture) return startNativeRecognition(generation, operationId);
+
         let stream;
         try {
             stream = await navigator.mediaDevices.getUserMedia({ audio: true });
@@ -1461,6 +1470,111 @@
         }
     }
 
+    function startNativeRecognition(generation, operationId) {
+        const session = {
+            generation,
+            operationId,
+            controller: new AbortController(),
+            capture: null,
+            text: [],
+            interim: '',
+            cancelled: false,
+            error: null
+        };
+        nativeCaptureSession = session;
+        function currentNativeCapture() {
+            return !destroyed && !session.cancelled
+                && nativeCaptureSession === session
+                && generation === recordingGeneration;
+        }
+        function displayNativeRecognitionText() {
+            if (!currentNativeCapture()) return;
+            localStatus = {
+                message: session.text.join('') + session.interim || 'Listening. Release to finish.',
+                tone: '',
+                owner: 'recording',
+                generation
+            };
+            renderStatus();
+        }
+        async function finishNativeRecognition(error = null) {
+            if (!currentNativeCapture()) return;
+            nativeCaptureSession = null;
+            recordingRequested = false;
+            resetRecordPress();
+            clearRecordingStatus(generation);
+            if (error && error !== session.error) {
+                session.error = error;
+                reportTranscriptionError(error);
+            }
+            // Keep confirmed final words after a service/cleanup failure. Only
+            // explicit cancellation or supersession abandons this submission.
+            if (session.text.length && !destroyed && !session.cancelled
+                && generation === recordingGeneration) {
+                transcriptionOperationId = operationId;
+                await transcribe(session.text.join(''));
+            } else if (transcriptionOperationId === operationId) {
+                transcriptionOperationId = null;
+            }
+            renderControls();
+            renderStatus();
+        }
+        try {
+            session.capture = providerRuntime.createTranscriptionCapture(
+                {
+                    continuous: true,
+                    onSegment: function retainFinalRecognition(segment) {
+                        if (!currentNativeCapture()) return;
+                        session.text.push(segment.text);
+                        displayNativeRecognitionText();
+                    },
+                    onInterim: function displayInterimRecognition(result) {
+                        if (!currentNativeCapture()) return;
+                        session.interim = result.text;
+                        displayNativeRecognitionText();
+                    },
+                    onError: function reportNativeRecognitionFailure(error) {
+                        if (!currentNativeCapture()) return;
+                        session.error = error;
+                        reportTranscriptionError(error);
+                    }
+                }
+            );
+            if (!session.capture) throw new Error('The selected live transcription service is unavailable.');
+            session.capture.done.then(
+                function nativeRecognitionCompleted() {
+                    return finishNativeRecognition();
+                },
+                finishNativeRecognition
+            ).catch(
+                function reportNativeRecognitionSettlementFailure(error) {
+                    if (destroyed || generation !== recordingGeneration) return;
+                    reportTranscriptionError(error);
+                }
+            );
+            // No awaited preparation precedes the browser's gesture-bound start.
+            const starting = session.capture.start({signal: session.controller.signal});
+            return Promise.resolve(starting).catch(
+                function reportNativeRecognitionStartupFailure(error) {
+                    if (!currentNativeCapture()) return false;
+                    session.capture.cancel();
+                    nativeCaptureSession = null;
+                    recordingRequested = false;
+                    resetRecordPress();
+                    if (error !== session.error) reportTranscriptionError(error);
+                    return false;
+                }
+            );
+        } catch (error) {
+            session.capture?.cancel();
+            nativeCaptureSession = null;
+            recordingRequested = false;
+            resetRecordPress();
+            if (error !== session.error) reportTranscriptionError(error);
+            return false;
+        }
+    }
+
     function stopAfterSilence() {
         clearSilenceTimer();
         stop();
@@ -1483,6 +1597,12 @@
     }
 
     function stop() {
+        if (nativeCaptureSession) {
+            recordingRequested = false;
+            nativeCaptureSession.capture.stop();
+            renderControls();
+            return true;
+        }
         const pendingCaptureStart = recordingRequested && !captureSession;
         const generation = recordingGeneration;
         const operationId = transcriptionOperationId;
@@ -1703,6 +1823,7 @@
     function cancelSTTOperation(reason) {
         const hadActiveOperation = recordingRequested
             || Boolean(captureSession)
+            || Boolean(nativeCaptureSession)
             || transcriptionActive;
         recordingGeneration += 1;
         transcriptionGeneration += 1;
@@ -1713,6 +1834,14 @@
         clearSilenceTimer();
         resetRecordPress();
 
+        if (nativeCaptureSession) {
+            const session = nativeCaptureSession;
+            nativeCaptureSession = null;
+            session.cancelled = true;
+            session.controller.abort();
+            session.capture?.cancel();
+        }
+
         if (captureSession) {
             captureSession.cancelled = true;
             if (captureSession.recorder.state !== 'inactive') {
@@ -1769,6 +1898,7 @@
 
     function handlePageHide(event) {
         if (event.persisted === true) {
+            if (nativeCaptureSession) stop();
             return;
         }
         destroy();

package/runtime/arcane/components/voice-transcription.html

@@ -82,6 +82,7 @@
     <p id="description" class="description" part="description"></p>
     <section id="transcript" class="transcript" part="transcript"></section>
     <div class="transcription-feedback">
+        <p id="interim" class="status" part="interim" aria-live="polite" hidden></p>
         <p id="status" class="status" part="status" role="status" aria-live="polite"></p>
         <progress
             id="sttActivationProgress"
@@ -136,16 +137,20 @@
         {default:MD},
         {appendTranscription,createSTTActivationController,normalizeVoiceOptions},
         {requestAIRuntimeIntent,subscribeAIRuntimeState},
-        {default:ContinuousVoiceCapture}
+        {default:ContinuousVoiceCapture},
+        {getAIProviderRuntime}
     ]=await Promise.all([
         import('../modules/MD.js'),
         import('../modules/ComponentContracts.js'),
         import('../modules/AIRuntimeState.js'),
-        import('../modules/ContinuousVoiceCapture.js')
+        import('../modules/ContinuousVoiceCapture.js'),
+        import('../modules/AIProviderRuntime.js')
     ]);
+    const providerRuntime=getAIProviderRuntime();
     const description=host.shadowRoot.querySelector('#description');
     const transcriptElement=host.shadowRoot.querySelector('#transcript');
     const status=host.shadowRoot.querySelector('#status');
+    const interimElement=host.shadowRoot.querySelector('#interim');
     const startButton=host.shadowRoot.querySelector('#start');
     const sttActivationButton=host.shadowRoot.querySelector('#sttActivation');
     const sttActivationProgress = host.shadowRoot.querySelector('#sttActivationProgress');
@@ -385,6 +390,7 @@
             flushing:false,
             processing:'idle',
             queue:[],
+            interim:'',
             failure:null,
             captureError:null,
             worker:null,
@@ -396,15 +402,25 @@
             if(!isCurrentContinuousSession(session)||!session.listening){
                 return false;
             }
-            session.capture=new ContinuousVoiceCapture({
+            const captureOptions={
                 ...options.capture,
                 onSegment:function capturedSegment(clip){
                     if(!isCurrentContinuousSession(session)){
                         return;
                     }
-                    session.queue.push({...clip,stage:'transcribe',segment:null});
+                    session.queue.push({
+                        ...clip,
+                        stage:is.string(clip.text)?'append':'transcribe',
+                        segment:is.string(clip.text)?clip.text:null
+                    });
+                    renderInterimRecognition(session);
                     processContinuousQueue(session);
                 },
+                onInterim:function displayInterimRecognition(result){
+                    if(!isCurrentContinuousSession(session)) return;
+                    session.interim=result.text;
+                    renderInterimRecognition(session);
+                },
                 onState:function captureStateChanged(nextState){
                     if(!isCurrentContinuousSession(session)){
                         return;
@@ -412,8 +428,11 @@
                     session.captureState=nextState;
                     if(nextState==='stopped'||nextState==='interrupted'){
                         session.listening=false;
+                        session.interim='';
+                        renderInterimRecognition(session);
                     }
                     renderContinuousState(session);
+                    settleContinuousDrain(session);
                 },
                 onError:function captureFailed(error){
                     if(!isCurrentContinuousSession(session)){
@@ -425,7 +444,29 @@
                     reportContinuousError(session,'capture',error);
                     settleContinuousDrain(session);
                 }
-            });
+            };
+            session.capture=!options.transcribe
+                ?providerRuntime.createTranscriptionCapture(captureOptions):null;
+            session.native=Boolean(session.capture);
+            if(!session.capture){
+                session.capture=new ContinuousVoiceCapture(captureOptions);
+            }else{
+                session.capture.done.then(function nativeRecognitionEnded(){
+                    if(!isCurrentContinuousSession(session)) return;
+                    session.listening=false;
+                    session.interim='';
+                    renderInterimRecognition(session);
+                    if(!session.captureError) session.captureState='stopped';
+                    renderContinuousState(session);
+                    settleContinuousDrain(session);
+                }).catch(function nativeRecognitionCleanupFailed(error){
+                    if(!isCurrentContinuousSession(session)) return;
+                    session.captureError=error;
+                    session.listening=false;
+                    reportContinuousError(session,'capture',error);
+                    settleContinuousDrain(session);
+                });
+            }
             const started=await session.capture.start({
                 mediaConstraints:options.mediaConstraints,
                 signal:session.controller.signal
@@ -467,6 +508,17 @@
         };
     }
 
+    function renderInterimRecognition(session){
+        if(!isCurrentContinuousSession(session)) return;
+        const pending=[];
+        for(const clip of session.queue){
+            if(clip.stage==='append') pending.push(clip.segment);
+        }
+        const text=pending.join(options.separator)+session.interim;
+        interimElement.textContent=text;
+        interimElement.hidden=text.length===0;
+    }
+
     function renderContinuousState(session){
         if(!isCurrentContinuousSession(session)){
             return;
@@ -598,7 +650,10 @@
                         throw new TypeError('Transcription must return the complete text as a string.');
                     }
                     clip.segment=result;
-                    if(result.length===0){
+                    clip.stage='append';
+                }
+                if(clip.stage==='append'){
+                    if(clip.segment.length===0){
                         session.queue.shift();
                         const detail={sequence:clip.sequence,transcript};
                         dispatchVoiceEvent('voice-transcription-empty',detail,{
@@ -606,10 +661,11 @@
                         });
                         continue;
                     }
-                    clip.transcript=appendTranscription(transcript,result,options.separator);
+                    clip.transcript=appendTranscription(transcript,clip.segment,options.separator);
                     clip.stage='save';
                     transcript=clip.transcript;
                     renderTranscript();
+                    renderInterimRecognition(session);
                 }
                 if(options.persist){
                     const save=options.onSave||(is.function(host.save)?host.save.bind(host):null);
@@ -740,6 +796,8 @@
             return false;
         }
         continuousSession=null;
+        interimElement.textContent='';
+        interimElement.hidden=true;
         session.controller.abort();
         session.requestController?.abort();
         session.capture?.cancel();
@@ -766,7 +824,8 @@
     }
 
     async function startRecording(){
-        if(options.capture.mode==='continuous'){
+        if(options.capture.mode==='continuous'
+            ||(!options.transcribe&&providerRuntime.supportsTranscriptionCapture())){
             return startContinuousRecording();
         }
         if(!canStartVoiceRecording(sttRole,state,destroyed)){
@@ -1366,6 +1425,16 @@
         sttActivationController.synchronize(sttRole);
         if(continuousSession){
             const session=continuousSession;
+            if(session.native&&session.listening
+                &&(sttRole.state!=='ready'
+                    ||previousRole.providerId!==sttRole.providerId
+                    ||previousRole.modelId!==sttRole.modelId)){
+                session.capture?.cancel();
+                session.listening=false;
+                session.captureState='interrupted';
+                session.interim='';
+                renderInterimRecognition(session);
+            }
             if(['completing','complete'].includes(state)){
                 renderState();
                 return;

package/runtime/arcane/css/theme.css

@@ -327,3 +327,44 @@ body{
     scroll-behavior:auto !important;
     transition-duration:.01ms !important;
 }
+
+/* Paper uses the existing base light palette regardless of the screen skin.
+ * Print-only importance also overrides custom-theme inline tokens; no saved
+ * preference, screen layout, media paint, or scrolling state changes here.
+ */
+@media print {
+    @page {
+        margin: 15mm;
+    }
+
+    :root,
+    body,
+    [data-arcane-palette] {
+        color-scheme: light !important;
+        --background: rgb(255, 255, 255) !important;
+        --modal-background: rgb(255, 255, 255) !important;
+        --text-color: rgb(23, 34, 56) !important;
+        --primary-color: rgb(23, 34, 56) !important;
+        --secondary-color: rgb(229, 233, 243) !important;
+        --accent-color: var(--focus-color) !important;
+        --button-text-color: rgb(255, 255, 255) !important;
+        --border-color: rgb(203, 211, 226) !important;
+        --focus-color: rgb(118, 87, 213) !important;
+        --muted-text-color: rgb(95, 107, 130) !important;
+        --success-color: rgb(39, 122, 75) !important;
+        --warning-color: rgb(154, 101, 0) !important;
+        --danger-color: rgb(165, 56, 56) !important;
+        --review-color: rgb(133, 85, 165) !important;
+        --shadow-color: rgba(23, 34, 56, .16) !important;
+        --platinum: rgb(102, 112, 133) !important;
+        --icon-filter: none !important;
+        --file-icon-filter: hue-rotate(8deg) saturate(.62) brightness(.86) !important;
+    }
+
+    html,
+    body {
+        margin: 0;
+        background-color: var(--modal-background);
+        color: var(--text-color);
+    }
+}

package/runtime/arcane/modules/AI.js

@@ -2081,8 +2081,10 @@ class AI {
     #assertDeviceSpeechConfiguration(configuration){
         for(const routeName of ['default','localOnly']){
             const selection=configuration?.stt?.[routeName];
-            if(selection&&selection.localOnly!==true){
-                const error=new TypeError('Speech recognition supports on-device providers only.');
+            const liveCapture=selection
+                &&this.#providerRuntime.supportsTranscriptionCapture(selection.providerId);
+            if(selection&&selection.localOnly!==true&&!liveCapture){
+                const error=new TypeError('Speech recognition requires an on-device or explicitly selected live-capture provider.');
                 error.code='AI_STT_DEVICE_ONLY';
                 throw error;
             }
@@ -3430,8 +3432,9 @@ class AI {
         if(provider!==null&&provider?.role!==role){
             throw new TypeError('The speech provider must implement the selected role.');
         }
-        if(role==='stt'&&provider&&provider.localOnly!==true){
-            const error=new TypeError('Speech recognition supports on-device providers only.');
+        if(role==='stt'&&provider&&provider.localOnly!==true
+            &&!is.function(provider.createCapture)){
+            const error=new TypeError('Speech recognition requires an on-device or explicitly selected live-capture provider.');
             error.code='AI_STT_DEVICE_ONLY';
             throw error;
         }
@@ -6875,6 +6878,14 @@ class AI {
         }
     }
 
+    supportsTranscriptionCapture(){
+        return this.#providerRuntime.supportsTranscriptionCapture();
+    }
+
+    createTranscriptionCapture(options={}){
+        return this.#providerRuntime.createTranscriptionCapture(options);
+    }
+
     async fetchSTT(audioFile,signal=null){
         const callId=this.#traceSpeech('fetchSTT.call',{audioFile,aborted:signal?.aborted});
         try{

package/runtime/arcane/modules/AIProviderRuntime.js

@@ -1366,6 +1366,9 @@ function validateProvider(provider) {
     for (const method of PROVIDER_METHODS) {
         record[method] = provider[method].bind(provider);
     }
+    if (provider.role === 'stt' && is.function(provider.createCapture)) {
+        record.createCapture = provider.createCapture.bind(provider);
+    }
     const admitted = completeValue(record);
     PROVIDER_RECORDS.set(provider, admitted);
     return admitted;
@@ -4103,6 +4106,121 @@ export class AIProviderRuntime {
         return this.#roleRequestAlias('llm', 'stream', payload, options);
     }
 
+    supportsTranscriptionCapture(providerId = null) {
+        const slot = this.#slots.stt;
+        const provider = providerId === null
+            ? this.#providerFor(slot)
+            : this.#providers.get(providerKey('stt', providerId));
+        return is.function(provider?.createCapture);
+    }
+
+    createTranscriptionCapture(options = {}) {
+        this.#assertOpen();
+        this.#assertNotConfiguring();
+        const slot = this.#slots.stt;
+        const provider = this.#providerFor(slot);
+        if (!is.function(provider?.createCapture)) return null;
+
+        const runtime = this;
+        const generation = slot.generation;
+        const capture = provider.createCapture(options);
+        const controller = new AbortController();
+        let requestRecord = null;
+        let detachSignal = null;
+        let started = false;
+        let closed = false;
+        const done = Promise.resolve(capture.done).finally(
+            function releaseTranscriptionCapture() {
+                closed = true;
+                detachSignal?.();
+                if (!requestRecord) return;
+                slot.activeRequests.delete(requestRecord.requestSequence);
+                runtime.#drainRoleRequestQueue(slot);
+                if (slot.generation !== generation || slot.unloadPromise) return;
+                if (slot.activeRequests.size || slot.requestQueue.length) {
+                    runtime.#publishRoleRequestState(slot);
+                    return;
+                }
+                const status = validateProviderStatus(provider.status());
+                slot.ready = status.state === 'ready' && status.loaded && !status.busy;
+                publishAIRuntimeRoleState(
+                    'stt',
+                    roleRecord(
+                        'stt',
+                        slot.selection,
+                        {state: slot.ready ? 'ready' : 'unloaded', loaded: status.loaded}
+                    )
+                );
+            }
+        );
+        done.catch(
+            function observeTranscriptionCaptureCleanupFailure(error) {
+                arcaneLogging.error('Transcription capture cleanup failed.', error);
+            }
+        );
+        // Capture has its own synchronous start boundary so native microphone
+        // permission retains the originating user gesture. It is never queued.
+        return {
+            done,
+            start({signal} = {}) {
+                if (started || closed) return Promise.resolve(false);
+                try {
+                    runtime.#assertOpen();
+                    runtime.#assertNotConfiguring();
+                    const status = validateProviderStatus(provider.status());
+                    if (slot.generation !== generation || !slot.ready
+                        || slot.unloadPromise || slot.disposePromise
+                        || slot.activeRequests.size || slot.requestQueue.length
+                        || status.state !== 'ready' || !status.loaded || status.busy) {
+                        throw operationError(
+                            'The selected transcription capture provider is not ready.',
+                            'ARCANE_AI_ROLE_NOT_READY'
+                        );
+                    }
+                    assertAbortSignal(signal);
+                    started = true;
+                    detachSignal = runtime.#forwardAbort(signal, controller);
+                    const requestSequence = runtime.#nextRequestSequence(slot);
+                    requestRecord = {
+                        controller,
+                        requestSequence,
+                        operationId: runtime.#nextOperationId(slot, 'capture'),
+                        promise: done,
+                        cancel: function cancelOwnedTranscriptionCapture(reason) {
+                            controller.abort(reason);
+                            capture.cancel();
+                            return done;
+                        }
+                    };
+                    slot.activeRequests.set(requestSequence, requestRecord);
+                    runtime.#publishRoleRequestState(slot);
+                    const starting = capture.start({signal: controller.signal});
+                    return Promise.resolve(starting).catch(
+                        function releaseFailedTranscriptionCaptureStart(error) {
+                            capture.cancel();
+                            throw error;
+                        }
+                    );
+                } catch (error) {
+                    capture.cancel();
+                    throw error;
+                }
+            },
+            stop() {
+                capture.stop();
+                return done;
+            },
+            cancel() {
+                controller.abort();
+                capture.cancel();
+            },
+            destroy() {
+                controller.abort();
+                capture.destroy();
+            }
+        };
+    }
+
     transcribe(payload, options = {}) {
         arcaneLogging.debug('[Arcane speech runtime] transcribe', payload, options);
         return this.#roleRequestAlias('stt', 'transcribe', payload, options);

package/runtime/arcane/modules/MD.js

@@ -6,6 +6,20 @@ const markdownOptions = {
     async: false,
     pedantic: false,
     gfm: true,
+    tokenizer: {
+        html(src) {
+            const native = marked.Tokenizer.prototype.html.call(this, src);
+            if (native) return native;
+            // Quoted image values can contain blank lines that would otherwise
+            // split the tag into Markdown paragraphs before inline HTML parsing.
+            const image = /^ {0,3}<img(?:\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*\s*\/?>(?=[ \t]*(?:\n|$))/i;
+            const match = image.exec(src);
+            if (!match) return;
+            const quotedValues = match[0].match(/"[^"]*"|'[^']*'/g) || [];
+            if (!quotedValues.some(function containsNewline(value) {return value.includes('\n');})) return;
+            return {type:'html', block:true, raw:match[0], text:match[0]};
+        }
+    },
     renderer: {
         link(href, title, text) {
             const link = marked.Renderer.prototype.link.call(this, href, title, text);