technology software

documentation technical

English

You're looking at domain 'auds-r-dev.pages.dev' on the developer-focused generic top-level domain (.dev) with subdomain 'auds-r-dev'. Its registrable label 'pages' stretches across 5 characters split between 2 vowels and three consonants. Splitting it apart reveals one word: pages. No strong language cues emerged from the frequency lists.

html/4c/c5/4cc5ce00-8afc-423e-9afc-19a1a641395b.html.gz

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

69098e105d990f834cff1b7886d873444228ff63c590e5ff834d568f1115ed8b

4d50586b184724d39ddfe0f6582861664eddd5e806e5a79e0dbaa832361414d0

d2ea6c1e0cabca20d18e924b25a1cd0187c38ba7c33f60ab06e1b0402b9bcdb5

caf90641b0a01eeec1e2fefaa84158a06330c2db747cd767c9beeddad2a0462f

f48d81545d5edda68f4a8fc0e8aa8f542e7698703993669ba84fc1cb47ae4cfc

41181eeec6d7ba64cb9165f0e95563e34e026bde79e7c13aeec83270429b6fae

5b80cc4165a661a3f2060d6bdb5ccff591f04c4f8e39a06c12d3c2544587cb17

6a773656fcf6fad1f3124e9a10f31a9218710fdc6397d1744594d8a7dfa6d065

8ea3307c30c3ca6aca9fef3b9e374ab0bf3893e2001724de2a83c3130835ebe2

c57339c3fa16b1d69d9a6b46749a8139ef8d4fc9bbfe48144ff897aa7d4222ec

e17a1d816e13c0826e0ed7febfabc3277f45571234bde0bf9120829a7169edc9

a3e9c8c52dd54d783a6d9294357ef104d17d03faf0a404b592216c0d71a9f717

f1d77fdab0899b8cadac2269f8cad8cfbcb66885fa7ac4f618fb4401f0dfebfa

77d9bf9f254ee557bbda5a001827791586810ea7e221c00ce1f1a334f41e11ae

939bf1287d7859a2bd0e9142f2a66ab2639b6a708a0ebaf2ab4343e716941cbd

b685d6ad9b22c04e3f55bcf54e56db7fed463bc881bc92007406e9879a0ec6be

3f92186c0a4799d495eae04c92864af11d854357b2d9dc2435a6ee0cc8469072

67cd549bb3818c4de706b725637f0e27058d34b802c1b074c95c9d0c1e3815c6

a5a7f8f88a4cb82f14b65a416088682cd96d08fbbfa328204961f20a6b200ac6

e9f7f4851dd87b4f72fd98a3bb718ce97c0ecc65c1595c65b83580e8bf6a1441

d86cf1e11de4202b18ca9e0f7e323a86edde565e94668e3692bb56251c25b18e

4fd5723545b2c4937cc0e9a9cbbf1f93d2c018a4b9a22790d58761493d6539c6

57b60e1217f64e0aea3644c0992d130d4483d6af065d47f093375bd603f84b0a

75b480ab1bba0135ddefd1cec1e37b352f51a6be0ac2c857b59175ac84e12af4

f483d0430643ed77bfcf99dff857222cbb53f63623618ff22b852e5b0c1c4bee

736edd775266ae3521822438eb44f1d7575b785867dccf3378859019827e17e1

fa4e12056f3f1c55f0ac62f182c47bb6165e1991e2cbb4f976641990f079cf2b

5a6d82cf70d0a01eb3dda54049fb517db38702c57f53fa6448aeb657f7beebd1

c5e44c0124501089fb0c1856e67ef90f8004ca5902083e06a353fbec060a7878

CS229 Introduction to Data Science with R

Lecture 11 - Introduction to Machine Learning

Lecture 13 - Navigating Data Science Projects Lifecycle

generator

width=device-width, initial-scale=1.0, user-scalable=yes

viewport

quarto:offset

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

Abuse Team

CloudFlare, Inc.

pages.dev

Cloudflare Abuse Contact

MNT-CLOUDFLARE

Cloudflare Technical Contact

CLOUDFLARENET-EU

Clear

Copy link to search

Cancel

Submit


// Document level settings ----

// Determine if we need to install R packages
globalThis.qwebrInstallRPackagesList = [''];

// Specify possible locations to search for the repository
globalThis.qwebrPackageRepoURLS = ['https://repo.r-wasm.org/'];

// Check to see if we have an empty array, if we do set to skip the installation.
globalThis.qwebrSetupRPackages = !(qwebrInstallRPackagesList.indexOf("") !== -1);
globalThis.qwebrAutoloadRPackages = true;

// Display a startup message?
globalThis.qwebrShowStartupMessage = true;
globalThis.qwebrShowHeaderMessage = false;

// Describe the webR settings that should be used
globalThis.qwebrCustomizedWebROptions = {
  "baseURL": "https://webr.r-wasm.org/v0.4.0/",
  "serviceWorkerUrl": "",
  "homedir": "/home/web_user", 
  "channelType": "ChannelType.Automatic"
};

// Store cell data
globalThis.qwebrCellDetails = [{"options":{"output":"true","classes":"","context":"interactive","results":"markup","read-only":"false","fig-cap":"","comment":"","dpi":72,"editor-max-height":"","fig-height":5,"editor-quick-suggestions":"false","autorun":"false","warning":"true","out-height":"","out-width":"700px","fig-width":7,"editor-font-scale":"1","label":"unnamed-chunk-1","editor-word-wrap":"true","message":"true"},"code":"","id":1},{"options":{"output":"true","classes":"","context":"interactive","results":"markup","read-only":"false","fig-cap":"","comment":"","dpi":72,"editor-max-height":"","fig-height":5,"editor-quick-suggestions":"false","autorun":"false","warning":"true","out-height":"","out-width":"700px","fig-width":7,"editor-font-scale":"1","label":"unnamed-chunk-2","editor-word-wrap":"true","message":"true"},"code":"","id":2}];



// Declare startupMessageQWebR globally
globalThis.qwebrStartupMessage = document.createElement("p");

// Verify if OffScreenCanvas is supported
globalThis.qwebrOffScreenCanvasSupport = function() {
 return typeof OffscreenCanvas !== 'undefined'
}

// Function to set the button text
globalThis.qwebrSetInteractiveButtonState = function(buttonText, enableCodeButton = true) {
 document.querySelectorAll(".qwebr-button-run").forEach((btn) => {
 btn.innerHTML = buttonText;
 btn.disabled = !enableCodeButton;
 });
}

// Function to update the status message in non-interactive cells
globalThis.qwebrUpdateStatusMessage = function(message) {
 document.querySelectorAll(".qwebr-status-text.qwebr-cell-needs-evaluation").forEach((elem) => {
 elem.innerText = message;
 });
}

// Function to update the status message
globalThis.qwebrUpdateStatusHeader = function(message) {
 qwebrStartupMessage.innerHTML = `
 
 ${message}`;
}

// Function to return true if element is found, false if not
globalThis.qwebrCheckHTMLElementExists = function(selector) {
 const element = document.querySelector(selector);
 return !!element;
}

// Function that detects whether reveal.js slides are present
globalThis.qwebrIsRevealJS = function() {
 // If the '.reveal .slides' selector exists, RevealJS is likely present
 return qwebrCheckHTMLElementExists('.reveal .slides');
}

// Initialize the Quarto sidebar element
function qwebrSetupQuartoSidebar() {
 var newSideBarDiv = document.createElement('div');
 newSideBarDiv.id = 'quarto-margin-sidebar';
 newSideBarDiv.className = 'sidebar margin-sidebar';
 newSideBarDiv.style.top = '0px';
 newSideBarDiv.style.maxHeight = 'calc(0px + 100vh)';

 return newSideBarDiv;
}

// Position the sidebar in the document
function qwebrPlaceQuartoSidebar() {
 // Get the reference to the element with id 'quarto-document-content'
 var referenceNode = document.getElementById('quarto-document-content');

 // Create the new div element
 var newSideBarDiv = qwebrSetupQuartoSidebar();

 // Insert the new div before the 'quarto-document-content' element
 referenceNode.parentNode.insertBefore(newSideBarDiv, referenceNode);
}

function qwebrPlaceMessageContents(content, html_location = "title-block-header", revealjs_location = "title-slide") {

 // Get references to header elements
 const headerHTML = document.getElementById(html_location);
 const headerRevealJS = document.getElementById(revealjs_location);

 // Determine where to insert the quartoTitleMeta element
 if (headerHTML || headerRevealJS) {
 // Append to the existing "title-block-header" element or "title-slide" div
 (headerHTML || headerRevealJS).appendChild(content);
 } else {
 // If neither headerHTML nor headerRevealJS is found, insert after "webr-monaco-editor-init" script
 const monacoScript = document.getElementById("qwebr-monaco-editor-init");
 const header = document.createElement("header");
 header.setAttribute("id", "title-block-header");
 header.appendChild(content);
 monacoScript.after(header);
 }
}



function qwebrOffScreenCanvasSupportWarningMessage() {
 
 // Verify canvas is supported.
 if(qwebrOffScreenCanvasSupport()) return;

 // Create the main container div
 var calloutContainer = document.createElement('div');
 calloutContainer.classList.add('callout', 'callout-style-default', 'callout-warning', 'callout-titled');

 // Create the header div
 var headerDiv = document.createElement('div');
 headerDiv.classList.add('callout-header', 'd-flex', 'align-content-center');

 // Create the icon container div
 var iconContainer = document.createElement('div');
 iconContainer.classList.add('callout-icon-container');

 // Create the icon element
 var iconElement = document.createElement('i');
 iconElement.classList.add('callout-icon');

 // Append the icon element to the icon container
 iconContainer.appendChild(iconElement);

 // Create the title container div
 var titleContainer = document.createElement('div');
 titleContainer.classList.add('callout-title-container', 'flex-fill');
 titleContainer.innerText = 'Warning: Web Browser Does Not Support Graphing!';

 // Append the icon container and title container to the header div
 headerDiv.appendChild(iconContainer);
 headerDiv.appendChild(titleContainer);

 // Create the body container div
 var bodyContainer = document.createElement('div');
 bodyContainer.classList.add('callout-body-container', 'callout-body');

 // Create the paragraph element for the body content
 var paragraphElement = document.createElement('p');
 paragraphElement.innerHTML = 'This web browser does not have support for displaying graphs through the <code>quarto-webr</code> extension since it lacks an <code>OffScreenCanvas</code>. Please upgrade your web browser to one that supports <code>OffScreenCanvas</code>.';

 // Append the paragraph element to the body container
 bodyContainer.appendChild(paragraphElement);

 // Append the header div and body container to the main container div
 calloutContainer.appendChild(headerDiv);
 calloutContainer.appendChild(bodyContainer);

 // Append the main container div to the document depending on format
 qwebrPlaceMessageContents(calloutContainer, "title-block-header"); 

}


// Function that attaches the document status message and diagnostics
function displayStartupMessage(showStartupMessage, showHeaderMessage) {
 if (!showStartupMessage) {
 return;
 }

 // Create the outermost div element for metadata
 const quartoTitleMeta = document.createElement("div");
 quartoTitleMeta.classList.add("quarto-title-meta");

 // Create the first inner div element
 const firstInnerDiv = document.createElement("div");
 firstInnerDiv.setAttribute("id", "qwebr-status-message-area");

 // Create the second inner div element for "WebR Status" heading and contents
 const secondInnerDiv = document.createElement("div");
 secondInnerDiv.setAttribute("id", "qwebr-status-message-title");
 secondInnerDiv.classList.add("quarto-title-meta-heading");
 secondInnerDiv.innerText = "WebR Status";

 // Create another inner div for contents
 const secondInnerDivContents = document.createElement("div");
 secondInnerDivContents.setAttribute("id", "qwebr-status-message-body");
 secondInnerDivContents.classList.add("quarto-title-meta-contents");

 // Describe the WebR state
 qwebrStartupMessage.innerText = "🟡 Loading...";
 qwebrStartupMessage.setAttribute("id", "qwebr-status-message-text");
 // Add `aria-live` to auto-announce the startup status to screen readers
 qwebrStartupMessage.setAttribute("aria-live", "assertive");

 // Append the startup message to the contents
 secondInnerDivContents.appendChild(qwebrStartupMessage);

 // Add a status indicator for COOP and COEP Headers if needed
 if (showHeaderMessage) {
 const crossOriginMessage = document.createElement("p");
 crossOriginMessage.innerText = `${crossOriginIsolated ? '🟢' : '🟡'} COOP & COEP Headers`;
 crossOriginMessage.setAttribute("id", "qwebr-coop-coep-header");
 secondInnerDivContents.appendChild(crossOriginMessage);
 }

 // Combine the inner divs and contents
 firstInnerDiv.appendChild(secondInnerDiv);
 firstInnerDiv.appendChild(secondInnerDivContents);
 quartoTitleMeta.appendChild(firstInnerDiv);

 // Place message on webpage
 qwebrPlaceMessageContents(quartoTitleMeta); 
}

function qwebrAddCommandHistoryModal() {
 // Create the modal div
 var modalDiv = document.createElement('div');
 modalDiv.id = 'qwebr-history-modal';
 modalDiv.className = 'qwebr-modal';

 // Create the modal content div
 var modalContentDiv = document.createElement('div');
 modalContentDiv.className = 'qwebr-modal-content';

 // Create the span for closing the modal
 var closeSpan = document.createElement('span');
 closeSpan.id = 'qwebr-command-history-close-btn';
 closeSpan.className = 'qwebr-modal-close';
 closeSpan.innerHTML = '&times;';

 // Create the h1 element for the modal
 var modalH1 = document.createElement('h1');
 modalH1.textContent = 'R History Command Contents';

 // Create an anchor element for downloading the Rhistory file 
 var downloadLink = document.createElement('a');
 downloadLink.href = '#';
 downloadLink.id = 'qwebr-download-history-btn';
 downloadLink.className = 'qwebr-download-btn';

 // Create an 'i' element for the icon
 var icon = document.createElement('i');
 icon.className = 'bi bi-file-code';

 // Append the icon to the anchor element
 downloadLink.appendChild(icon);

 // Add the text 'Download R History' to the anchor element
 downloadLink.appendChild(document.createTextNode(' Download R History File'));

 // Create the pre for command history contents
 var commandContentsPre = document.createElement('pre');
 commandContentsPre.id = 'qwebr-command-history-contents';
 commandContentsPre.className = 'qwebr-modal-content-code';

 // Append the close span, h1, and history contents pre to the modal content div
 modalContentDiv.appendChild(closeSpan);
 modalContentDiv.appendChild(modalH1);
 modalContentDiv.appendChild(downloadLink);
 modalContentDiv.appendChild(commandContentsPre);

 // Append the modal content div to the modal div
 modalDiv.appendChild(modalContentDiv);

 // Append the modal div to the body
 document.body.appendChild(modalDiv);
}

function qwebrRegisterRevealJSCommandHistoryModal() {
 // Select the <ul> element inside the <div> with data-panel="Custom0"
 let ulElement = document.querySelector('div[data-panel="Custom0"] > ul.slide-menu-items');

 // Find the last <li> element with class slide-tool-item
 let lastItem = ulElement.querySelector('li.slide-tool-item:last-child');

 // Calculate the next data-item value
 let nextItemValue = 0;
 if (lastItem) {
 nextItemValue = parseInt(lastItem.dataset.item) + 1;
 }

 // Create a new <li> element
 let newListItem = document.createElement('li');
 newListItem.className = 'slide-tool-item';
 newListItem.dataset.item = nextItemValue.toString(); // Set the next available data-item value

 // Create the <a> element inside the <li>
 let newLink = document.createElement('a');
 newLink.href = '#';
 newLink.id = 'qwebrRHistoryButton'; // Set the ID for the new link
 
 // Create the <kbd> element inside the <a>
 let newKbd = document.createElement('kbd');
 newKbd.textContent = ' '; // Set to empty as we are not registering a keyboard shortcut

 // Create text node for the link text
 let newText = document.createTextNode(' View R History');

 // Append <kbd> and text node to <a>
 newLink.appendChild(newKbd);
 newLink.appendChild(newText);

 // Append <a> to <li>
 newListItem.appendChild(newLink);

 // Append <li> to <ul>
 ulElement.appendChild(newListItem);
}

// Handle setting up the R history modal
function qwebrCodeLinks() {

 if (qwebrIsRevealJS()) {
 qwebrRegisterRevealJSCommandHistoryModal();
 return;
 }

 // Create the container div
 var containerDiv = document.createElement('div');
 containerDiv.className = 'quarto-code-links';

 // Create the h2 element
 var h2 = document.createElement('h2');
 h2.textContent = 'webR Code Links';

 // Create the ul element
 var ul = document.createElement('ul');

 // Create the li element
 var li = document.createElement('li');

 // Create the a_history_btn element
 var a_history_btn = document.createElement('a');
 a_history_btn.href = 'javascript:void(0)';
 a_history_btn.setAttribute('id', 'qwebrRHistoryButton');

 // Create the i_history_btn element
 var i_history_btn = document.createElement('i');
 i_history_btn.className = 'bi bi-file-code';

 // Create the text node for the link text
 var text_history_btn = document.createTextNode('View R History');

 // Append the icon element and link text to the a element
 a_history_btn.appendChild(i_history_btn);
 a_history_btn.appendChild(text_history_btn);

 // Append the a element to the li element
 li.appendChild(a_history_btn);

 // Append the li element to the ul element
 ul.appendChild(li);

 // Append the h2 and ul elements to the container div
 containerDiv.appendChild(h2);
 containerDiv.appendChild(ul);

 // Append the container div to the element with the ID 'quarto-margin-sidebar'
 var sidebar = document.getElementById('quarto-margin-sidebar');
 
 // If the sidebar element is not found, create it
 if(!sidebar) {
 qwebrPlaceQuartoSidebar();
 }
 
 // Re-select the sidebar element (if it was just created)
 sidebar = document.getElementById('quarto-margin-sidebar'); 


 // If the sidebar element exists, append the container div to it
 if(sidebar) {
 // Append the container div to the sidebar
 sidebar.appendChild(containerDiv);
 // Force the sidebar to be clickable by removing the 'zindex-bottom' class
 // added in pre-release: https://github.com/quarto-dev/quarto-cli/commit/f0c53a1ffcaa1de4eccbf07803b096898248adcc
 sidebar.className = 'sidebar margin-sidebar';
 } else {
 // Get a debugger ...
 console.warn('Element with ID "quarto-margin-sidebar" not found.');
 }
}

// Call the function to append the code links for qwebR into the right sidebar
qwebrCodeLinks();

// Add the command history modal
qwebrAddCommandHistoryModal();

displayStartupMessage(qwebrShowStartupMessage, qwebrShowHeaderMessage);
qwebrOffScreenCanvasSupportWarningMessage();

// Define a global storage and retrieval solution ----

// Store commands executed in R
globalThis.qwebrRCommandHistory = [];

// Function to retrieve the command history
globalThis.qwebrFormatRHistory = function() {
 return qwebrRCommandHistory.join("\n\n");
}

// Retrieve HTML Elements ----

// Get the command modal
const command_history_modal = document.getElementById("qwebr-history-modal");

// Get the button that opens the command modal
const command_history_btn = document.getElementById("qwebrRHistoryButton");

// Get the element that closes the command modal
const command_history_close_span = document.getElementById("qwebr-command-history-close-btn");

// Get the download button for r history information
const command_history_download_btn = document.getElementById("qwebr-download-history-btn");

// Plug in command history into modal/download button ----

// Function to populate the modal with command history
function populateCommandHistoryModal() {
 document.getElementById("qwebr-command-history-contents").innerHTML = qwebrFormatRHistory() || "No commands have been executed yet.";
}

// Function to format the current date and time to
// a string with the format YYYY-MM-DD-HH-MM-SS
function formatDateTime() {
 const now = new Date();

 const year = now.getFullYear();
 const day = String(now.getDate()).padStart(2, '0');
 const month = String(now.getMonth() + 1).padStart(2, '0'); // Months are zero-based
 const hours = String(now.getHours()).padStart(2, '0');
 const minutes = String(now.getMinutes()).padStart(2, '0');
 const seconds = String(now.getSeconds()).padStart(2, '0');

 return `${year}-${month}-${day}-${hours}-${minutes}-${seconds}`;
}


// Function to convert document title with datetime to a safe filename
function safeFileName() {
 // Get the current page title
 let pageTitle = document.title;

 // Combine the current page title with the current date and time
 let pageNameWithDateTime = `Rhistory-${pageTitle}-${formatDateTime()}`;

 // Replace unsafe characters with safe alternatives
 let safeFilename = pageNameWithDateTime.replace(/[\\/:\*\?! "<>\|]/g, '-');

 return safeFilename;
}


// Function to download list contents as text file
function downloadRHistory() {
 // Get the current page title + datetime and use it as the filename
 const filename = `${safeFileName()}.R`;

 // Get the text contents of the R History list
 const text = qwebrFormatRHistory();

 // Create a new Blob object with the text contents
 const blob = new Blob([text], { type: 'text/plain' });
 
 // Create a new anchor element for the download
 const a = document.createElement('a');
 a.style.display = 'none';
 a.href = URL.createObjectURL(blob);
 a.download = filename;

 // Append the anchor to the body, click it, and remove it
 document.body.appendChild(a);
 a.click();
 document.body.removeChild(a);
}

// Register event handlers ----

// When the user clicks the View R History button, open the command modal
command_history_btn.onclick = function() {
 populateCommandHistoryModal();
 command_history_modal.style.display = "block";
}

// When the user clicks on (x), close the command modal
command_history_close_span.onclick = function() {
 command_history_modal.style.display = "none";
}

// When the user clicks anywhere outside of the command modal, close it
window.onclick = function(event) {
 if (event.target == command_history_modal) {
 command_history_modal.style.display = "none";
 }
}

// Add an onclick event listener to the download button so that
// the user can download the R history as a text file
command_history_download_btn.onclick = function() {
 downloadRHistory();
};

// Supported Evaluation Types for Context
globalThis.EvalTypes = Object.freeze({
 Interactive: 'interactive',
 Setup: 'setup',
 Output: 'output',
});

// Function that obtains the font size for a given element 
globalThis.qwebrCurrentFontSizeOnElement = function(element, cssProperty = 'font-size') {

 const currentFontSize = parseFloat(
 window
 .getComputedStyle(element)
 .getPropertyValue(cssProperty)
 );
 
 return currentFontSize;
}

// Function to determine font scaling
globalThis.qwebrScaledFontSize = function(div, qwebrOptions) {
 // Determine if we should compute font-size using RevealJS's `--r-main-font-size` 
 // or if we can directly use the document's `font-size`.
 const cssProperty = document.body.classList.contains('reveal') ? 
 "--r-main-font-size" : "font-size";
 
 // Get the current font size on the div element
 const elementFontSize = qwebrCurrentFontSizeOnElement(div, cssProperty);

 // Determine the scaled font size value
 const scaledFontSize = ((qwebrOptions['editor-font-scale'] ?? 1) * elementFontSize) ?? 17.5;

 return scaledFontSize;
}


// Function that dispatches the creation request
globalThis.qwebrCreateHTMLElement = function (
 cellData
) {

 // Extract key components
 const evalType = cellData.options.context;
 const qwebrCounter = cellData.id;

 // We make an assumption that insertion points are defined by the Lua filter as:
 // qwebr-insertion-location-{qwebrCounter} 
 const elementLocator = document.getElementById(`qwebr-insertion-location-${qwebrCounter}`);

 // Figure out the routine to use to insert the element.
 let qwebrElement;
 switch ( evalType ) {
 case EvalTypes.Interactive:
 qwebrElement = qwebrCreateInteractiveElement(qwebrCounter, cellData.options);
 break;
 case EvalTypes.Output: 
 qwebrElement = qwebrCreateNonInteractiveOutputElement(qwebrCounter, cellData.options);
 break;
 case EvalTypes.Setup: 
 qwebrElement = qwebrCreateNonInteractiveSetupElement(qwebrCounter, cellData.options);
 break;
 default: 
 qwebrElement = document.createElement('div');
 qwebrElement.textContent = 'Error creating `quarto-webr` element';
 }

 // Insert the dynamically generated object at the document location.
 elementLocator.appendChild(qwebrElement);
};

// Function that setups the interactive element creation
globalThis.qwebrCreateInteractiveElement = function (qwebrCounter, qwebrOptions) {

 // Create main div element
 var mainDiv = document.createElement('div');
 mainDiv.id = 'qwebr-interactive-area-' + qwebrCounter;
 mainDiv.className = `qwebr-interactive-area`;
 if (qwebrOptions.classes) {
 mainDiv.className += " " + qwebrOptions.classes
 }

 // Add a unique cell identifier that users can customize
 if (qwebrOptions.label) {
 mainDiv.setAttribute('data-id', qwebrOptions.label);
 }

 // Create toolbar div
 var toolbarDiv = document.createElement('div');
 toolbarDiv.className = 'qwebr-editor-toolbar';
 toolbarDiv.id = 'qwebr-editor-toolbar-' + qwebrCounter;

 // Create a div to hold the left buttons
 var leftButtonsDiv = document.createElement('div');
 leftButtonsDiv.className = 'qwebr-editor-toolbar-left-buttons';

 // Create a div to hold the right buttons
 var rightButtonsDiv = document.createElement('div');
 rightButtonsDiv.className = 'qwebr-editor-toolbar-right-buttons';

 // Create Run Code button
 var runCodeButton = document.createElement('button');
 runCodeButton.className = 'btn btn-default qwebr-button qwebr-button-run';
 runCodeButton.disabled = true;
 runCodeButton.type = 'button';
 runCodeButton.id = 'qwebr-button-run-' + qwebrCounter;
 runCodeButton.textContent = '🟡 Loading webR...';
 runCodeButton.title = `Run code (Shift + Enter)`;

 // Append buttons to the leftButtonsDiv
 leftButtonsDiv.appendChild(runCodeButton);

 // Create Reset button
 var resetButton = document.createElement('button');
 resetButton.className = 'btn btn-light btn-xs qwebr-button qwebr-button-reset';
 resetButton.type = 'button';
 resetButton.id = 'qwebr-button-reset-' + qwebrCounter;
 resetButton.title = 'Start over';
 resetButton.innerHTML = '';

 // Create Copy button
 var copyButton = document.createElement('button');
 copyButton.className = 'btn btn-light btn-xs qwebr-button qwebr-button-copy';
 copyButton.type = 'button';
 copyButton.id = 'qwebr-button-copy-' + qwebrCounter;
 copyButton.title = 'Copy code';
 copyButton.innerHTML = '';

 // Append buttons to the rightButtonsDiv
 rightButtonsDiv.appendChild(resetButton);
 rightButtonsDiv.appendChild(copyButton);

 // Create console area div
 var consoleAreaDiv = document.createElement('div');
 consoleAreaDiv.id = 'qwebr-console-area-' + qwebrCounter;
 consoleAreaDiv.className = 'qwebr-console-area';

 // Create editor div
 var editorDiv = document.createElement('div');
 editorDiv.id = 'qwebr-editor-' + qwebrCounter;
 editorDiv.className = 'qwebr-editor';

 // Create output code area div
 var outputCodeAreaDiv = document.createElement('div');
 outputCodeAreaDiv.id = 'qwebr-output-code-area-' + qwebrCounter;
 outputCodeAreaDiv.className = 'qwebr-output-code-area';
 outputCodeAreaDiv.setAttribute('aria-live', 'assertive');

 // Create pre element inside output code area
 var preElement = document.createElement('pre');
 preElement.style.visibility = 'hidden';
 outputCodeAreaDiv.appendChild(preElement);

 // Create output graph area div
 var outputGraphAreaDiv = document.createElement('div');
 outputGraphAreaDiv.id = 'qwebr-output-graph-area-' + qwebrCounter;
 outputGraphAreaDiv.className = 'qwebr-output-graph-area';

 // Append buttons to the toolbar
 toolbarDiv.appendChild(leftButtonsDiv);
 toolbarDiv.appendChild(rightButtonsDiv);

 // Append all elements to the main div
 mainDiv.appendChild(toolbarDiv);
 consoleAreaDiv.appendChild(editorDiv);
 consoleAreaDiv.appendChild(outputCodeAreaDiv);
 mainDiv.appendChild(consoleAreaDiv);
 mainDiv.appendChild(outputGraphAreaDiv);

 return mainDiv;
}

// Function that adds output structure for non-interactive output
globalThis.qwebrCreateNonInteractiveOutputElement = function(qwebrCounter, qwebrOptions) {
 // Create main div element
 var mainDiv = document.createElement('div');
 mainDiv.id = 'qwebr-noninteractive-area-' + qwebrCounter;
 mainDiv.className = `qwebr-noninteractive-area`;
 if (qwebrOptions.classes) {
 mainDiv.className += " " + qwebrOptions.classes
 }
 
 // Add a unique cell identifier that users can customize
 if (qwebrOptions.label) {
 mainDiv.setAttribute('data-id', qwebrOptions.label);
 }
 
 // Create a status container div
 var statusContainer = createLoadingContainer(qwebrCounter);

 // Create output code area div
 var outputCodeAreaDiv = document.createElement('div');
 outputCodeAreaDiv.id = 'qwebr-output-code-area-' + qwebrCounter;
 outputCodeAreaDiv.className = 'qwebr-output-code-area';
 outputCodeAreaDiv.setAttribute('aria-live', 'assertive');

 // Create pre element inside output code area
 var preElement = document.createElement('pre');
 preElement.style.visibility = 'hidden';
 outputCodeAreaDiv.appendChild(preElement);

 // Create output graph area div
 var outputGraphAreaDiv = document.createElement('div');
 outputGraphAreaDiv.id = 'qwebr-output-graph-area-' + qwebrCounter;
 outputGraphAreaDiv.className = 'qwebr-output-graph-area';

 // Append all elements to the main div
 mainDiv.appendChild(statusContainer);
 mainDiv.appendChild(outputCodeAreaDiv);
 mainDiv.appendChild(outputGraphAreaDiv);

 return mainDiv;
};

// Function that adds a stub in the page to indicate a setup cell was used.
globalThis.qwebrCreateNonInteractiveSetupElement = function(qwebrCounter, qwebrOptions) {
 // Create main div element
 var mainDiv = document.createElement('div');
 mainDiv.id = `qwebr-noninteractive-setup-area-${qwebrCounter}`;
 mainDiv.className = `qwebr-noninteractive-setup-area`;
 if (qwebrOptions.classes) {
 mainDiv.className += " " + qwebrOptions.classes
 }


 // Add a unique cell identifier that users can customize
 if (qwebrOptions.label) {
 mainDiv.setAttribute('data-id', qwebrOptions.label);
 }

 // Create a status container div
 var statusContainer = createLoadingContainer(qwebrCounter);

 // Append status onto the main div
 mainDiv.appendChild(statusContainer);

 return mainDiv;
}


// Function to create loading container with specified ID
globalThis.createLoadingContainer = function(qwebrCounter) {

 // Create a status container
 const container = document.createElement('div');
 container.id = `qwebr-non-interactive-loading-container-${qwebrCounter}`;
 container.className = 'qwebr-non-interactive-loading-container qwebr-cell-needs-evaluation';

 // Create an R project logo to indicate its a code space
 const rProjectIcon = document.createElement('i');
 rProjectIcon.className = 'fa-brands fa-r-project fa-3x qwebr-r-project-logo';

 // Setup a loading icon from font awesome
 const spinnerIcon = document.createElement('i');
 spinnerIcon.className = 'fa-solid fa-spinner fa-spin fa-1x qwebr-icon-status-spinner';

 // Add a section for status text
 const statusText = document.createElement('p');
 statusText.id = `qwebr-status-text-${qwebrCounter}`;
 statusText.className = `qwebr-status-text qwebr-cell-needs-evaluation`;
 statusText.innerText = 'Loading webR...';

 // Incorporate an inner container
 const innerContainer = document.createElement('div');

 // Append elements to the inner container
 innerContainer.appendChild(spinnerIcon);
 innerContainer.appendChild(statusText);

 // Append elements to the main container
 container.appendChild(rProjectIcon);
 container.appendChild(innerContainer);

 return container;
}

// Function to install a single package
async function qwebrInstallRPackage(packageName) {
 await mainWebR.evalRVoid(`webr::install('${packageName}');`);
}

// Function to load a single package
async function qwebrLoadRPackage(packageName) {
 await mainWebR.evalRVoid(`require('${packageName}', quietly = TRUE)`);
}

// Generic function to process R packages
async function qwebrProcessRPackagesWithStatus(packages, processType, displayStatusMessageUpdate = true) {
 // Switch between contexts
 const messagePrefix = processType === 'install' ? 'Installing' : 'Loading';

 // Modify button state
 qwebrSetInteractiveButtonState(`🟡 ${messagePrefix} package ...`, false);

 // Iterate over packages
 for (let i = 0; i < packages.length; i++) {
 const activePackage = packages[i];
 const formattedMessage = `${messagePrefix} package ${i + 1} out of ${packages.length}: ${activePackage}`;

 // Display the update in header
 if (displayStatusMessageUpdate) {
 qwebrUpdateStatusHeader(formattedMessage);
 }

 // Display the update in non-active areas
 qwebrUpdateStatusMessage(formattedMessage);

 // Run package installation
 if (processType === 'install') {
 await qwebrInstallRPackage(activePackage);
 } else {
 await qwebrLoadRPackage(activePackage);
 }
 }

 // Clean slate
 if (processType === 'load') {
 await mainWebR.flush();
 }
}

// Start a timer
const initializeWebRTimerStart = performance.now();

// Encase with a dynamic import statement
globalThis.qwebrInstance = import(qwebrCustomizedWebROptions.baseURL + "webr.mjs").then(
 async ({ WebR, ChannelType }) => {
 // Populate WebR options with defaults or new values based on `webr` meta
 globalThis.mainWebR = new WebR(qwebrCustomizedWebROptions);

 // Initialization WebR
 await mainWebR.init();

 // Setup a shelter
 globalThis.mainWebRCodeShelter = await new mainWebR.Shelter();

 // Setup a pager to allow processing help documentation
 await mainWebR.evalRVoid('webr::pager_install()');

 // Setup a viewer to allow processing htmlwidgets.
 // This might not be available in old webr version
 await mainWebR.evalRVoid('try({ webr::viewer_install() })');

 // Override the existing install.packages() to use webr::install()
 await mainWebR.evalRVoid('webr::shim_install()');

 // Specify the repositories to pull from
 // Note: webR does not use the `repos` option, but instead uses `webr_pkg_repos`
 // inside of `install()`. However, other R functions still pull from `repos`.
 await mainWebR.evalRVoid(`
 options(
 webr_pkg_repos = c(${qwebrPackageRepoURLS.map(repoURL => `'${repoURL}'`).join(',')}),
 repos = c(${qwebrPackageRepoURLS.map(repoURL => `'${repoURL}'`).join(',')})
 )
 `);

 // Check to see if any packages need to be installed
 if (qwebrSetupRPackages) {
 // Obtain only a unique list of packages
 const uniqueRPackageList = Array.from(new Set(qwebrInstallRPackagesList));

 // Install R packages one at a time (either silently or with a status update)
 await qwebrProcessRPackagesWithStatus(uniqueRPackageList, 'install', qwebrShowStartupMessage);

 if (qwebrAutoloadRPackages) {
 // Load R packages one at a time (either silently or with a status update)
 await qwebrProcessRPackagesWithStatus(uniqueRPackageList, 'load', qwebrShowStartupMessage);
 }
 }
 }
);

// Stop timer
const initializeWebRTimerEnd = performance.now();

// Function to verify a given JavaScript Object is empty
globalThis.qwebrIsObjectEmpty = function (arr) {
 return Object.keys(arr).length === 0;
}

// Global version of the Escape HTML function that converts HTML
// characters to their HTML entities.
globalThis.qwebrEscapeHTMLCharacters = function(unsafe) {
 return unsafe
 .replace(/&/g, "&amp;")
 .replace(/</g, "&lt;")
 .replace(/>/g, "&gt;")
 .replace(/"/g, "&quot;")
 .replace(/'/g, "&#039;");
};

// Passthrough results
globalThis.qwebrIdentity = function(x) {
 return x;
};

// Append a comment
globalThis.qwebrPrefixComment = function(x, comment) {
 return `${comment}${x}`;
};

// Function to store the code in the history
globalThis.qwebrLogCodeToHistory = function(codeToRun, options) {
 qwebrRCommandHistory.push(
 `# Ran code in ${options.label} at ${new Date().toLocaleString()} ----\n${codeToRun}`
 );
};

// Function to attach a download button onto the canvas
// allowing the user to download the image.
function qwebrImageCanvasDownloadButton(canvas, canvasContainer) {

 // Create the download button
 const downloadButton = document.createElement('button');
 downloadButton.className = 'qwebr-canvas-image-download-btn';
 downloadButton.textContent = 'Download Image';
 canvasContainer.appendChild(downloadButton);

 // Trigger a download of the image when the button is clicked
 downloadButton.addEventListener('click', function() {
 const image = canvas.toDataURL('image/png');
 const link = document.createElement('a');
 link.href = image;
 link.download = 'qwebr-canvas-image.png';
 link.click();
 });
}


// Function to parse the pager results
globalThis.qwebrParseTypePager = async function (msg) {

 // Split out the event data
 const { path, title, deleteFile } = msg.data;

 // Process the pager data by reading the information from disk
 const paged_data = await mainWebR.FS.readFile(path).then((data) => {
 // Obtain the file content
 let content = new TextDecoder().decode(data);

 // Remove excessive backspace characters until none remain
 while(content.match(/.[\b]/)){
 content = content.replace(/.[\b]/g, '');
 }

 // Returned cleaned data
 return content;
 });

 // Unlink file if needed
 if (deleteFile) {
 await mainWebR.FS.unlink(path);
 }

 // Return extracted data with spaces
 return paged_data;
};


// Function to parse the browse results
globalThis.qwebrParseTypeBrowse = async function (msg) {

 // msg.type === "browse"
 const path = msg.data.url;

 // Process the browse data by reading the information from disk
 const browse_data = await mainWebR.FS.readFile(path).then((data) => {
 // Obtain the file content
 let content = new TextDecoder().decode(data);

 return content;
 });

 // Return extracted data as-is
 return browse_data;
};

// Function to run the code using webR and parse the output
globalThis.qwebrComputeEngine = async function(
 codeToRun,
 elements,
 options) {

 // Call into the R compute engine that persists within the document scope.
 // To be prepared for all scenarios, the following happens:
 // 1. We setup a canvas device to write to by making a namespace call into the {webr} package
 // 2. We use values inside of the options array to set the figure size.
 // 3. We capture the output stream information (STDOUT and STERR)
 // 4. We disable the current device's image creation.
 // 5. Piece-wise parse the results into the different output areas

 // Create a pager variable for help/file contents
 let pager = [];

 // Handle how output is processed
 let showMarkup = options.results === "markup" && options.output !== "asis";
 let processOutput;

 if (showMarkup) {
 processOutput = qwebrEscapeHTMLCharacters;
 } else {
 processOutput = qwebrIdentity;
 }

 // ----
 // Convert from Inches to Pixels by using DPI (dots per inch)
 // for bitmap devices (dpi * inches = pixels)
 let fig_width = options["fig-width"] * options["dpi"];
 let fig_height = options["fig-height"] * options["dpi"];

 // Initialize webR
 await mainWebR.init();

 // Configure capture output
 let captureOutputOptions = {
 withAutoprint: true,
 captureStreams: true,
 captureConditions: false,
 // env: webR.objs.emptyEnv, // maintain a global environment for webR v0.2.0
 };

 // Determine if the browser supports OffScreen
 if (qwebrOffScreenCanvasSupport()) {
 // Mirror default options of webr::canvas()
 // with changes to figure height and width.
 captureOutputOptions.captureGraphics = {
 width: fig_width,
 height: fig_height,
 bg: "white", // default: transparent
 pointsize: 12,
 capture: true
 };
 } else {
 // Disable generating graphics
 captureOutputOptions.captureGraphics = false;
 }

 // Store the code to run in history
 qwebrLogCodeToHistory(codeToRun, options);

 // Setup a webR canvas by making a namespace call into the {webr} package
 // Evaluate the R code
 // Remove the active canvas silently
 const result = await mainWebRCodeShelter.captureR(
 `${codeToRun}`,
 captureOutputOptions
 );

 // -----

 // Start attempting to parse the result data
 processResultOutput:try {

 // Avoid running through output processing
 if (options.results === "hide" || options.output === "false") {
 break processResultOutput;
 }

 // Merge output streams of STDOUT and STDErr (messages and errors are combined.)
 // Require both `warning` and `message` to be true to display `STDErr`.
 const out = result.output
 .filter(
 evt => evt.type === "stdout" ||
 ( evt.type === "stderr" && (options.warning === "true" && options.message === "true"))
 )
 .map((evt, index) => {
 const className = `qwebr-output-code-${evt.type}`;
 const outputResult = qwebrPrefixComment(processOutput(evt.data), options.comment);
 return `<code id="${className}-editor-${elements.id}-result-${index + 1}" class="${className}">${outputResult}</code>`;
 })
 .join("\n");


 // Clean the state
 // We're now able to process pager events.
 // As a result, we cannot maintain a true 1-to-1 output order
 // without individually feeding each line
 const msgs = await mainWebR.flush();

 // Use `map` to process the filtered "pager" events asynchronously
 const pager = [];
 const browse = [];

 await Promise.all(
 msgs.map(
 async (msg) => {

 const msgType = msg.type || "unknown";

 switch(msgType) {
 case 'pager':
 const pager_data = await qwebrParseTypePager(msg);
 pager.push(pager_data);
 break;
 case 'browse':
 const browse_data = await qwebrParseTypeBrowse(msg);
 browse.push(browse_data);
 break;
 }
 return;
 }
 )
 );

 // Nullify the output area of content
 elements.outputCodeDiv.innerHTML = "";
 elements.outputGraphDiv.innerHTML = "";

 // Design an output object for messages
 const pre = document.createElement("pre");
 if (/\S/.test(out)) {
 // Display results as HTML elements to retain output styling
 const div = document.createElement("div");
 div.innerHTML = out;

 // Calculate a scaled font-size value
 const scaledFontSize = qwebrScaledFontSize(
 elements.outputCodeDiv, options);

 // Override output code cell size
 pre.style.fontSize = `${scaledFontSize}px`;
 pre.appendChild(div);
 } else {
 // If nothing is present, hide the element.
 pre.style.visibility = "hidden";
 }

 elements.outputCodeDiv.appendChild(pre);

 // Determine if we have graphs to display
 if (result.images.length > 0) {

 // Create figure element
 const figureElement = document.createElement("figure");
 figureElement.className = "qwebr-canvas-image";

 // Place each rendered graphic onto a canvas element
 result.images.forEach((img) => {

 // Construct canvas for object
 const canvas = document.createElement("canvas");

 // Add an image download button
 qwebrImageCanvasDownloadButton(canvas, figureElement);

 // Set canvas size to image
 canvas.width = img.width;
 canvas.height = img.height;

 // Apply output truncations
 canvas.style.width = options["out-width"] ? options["out-width"] : `${fig_width}px`;
 if (options["out-height"]) {
 canvas.style.height = options["out-height"];
 }

 // Apply styling
 canvas.style.display = "block";
 canvas.style.margin = "auto";

 // Draw image onto Canvas
 const ctx = canvas.getContext("2d");
 ctx.drawImage(img, 0, 0, img.width, img.height);

 // Append canvas to figure output area
 figureElement.appendChild(canvas);

 });

 if (options['fig-cap']) {
 // Create figcaption element
 const figcaptionElement = document.createElement('figcaption');
 figcaptionElement.innerText = options['fig-cap'];
 // Append figcaption to figure
 figureElement.appendChild(figcaptionElement);
 }

 elements.outputGraphDiv.appendChild(figureElement);

 }

 // Display the pager data
 if (pager.length > 0) {
 // Use the `pre` element to preserve whitespace.
 pager.forEach((paged_data, index) => {
 const pre_pager = document.createElement("pre");
 pre_pager.innerText = paged_data;
 pre_pager.classList.add("qwebr-output-code-pager");
 pre_pager.setAttribute("id", `qwebr-output-code-pager-editor-${elements.id}-result-${index + 1}`);
 elements.outputCodeDiv.appendChild(pre_pager);
 });
 }

 // Display the browse data
 if (browse.length > 0) {
 // Use the `pre` element to preserve whitespace.
 browse.forEach((browse_data, index) => {
 const iframe_browse = document.createElement('iframe');
 iframe_browse.classList.add("qwebr-output-code-browse");
 iframe_browse.setAttribute("id", `qwebr-output-code-browse-editor-${elements.id}-result-${index + 1}`);
 iframe_browse.style.width = "100%";
 iframe_browse.style.minHeight = "500px";
 elements.outputCodeDiv.appendChild(iframe_browse);

 iframe_browse.contentWindow.document.open();
 iframe_browse.contentWindow.document.write(browse_data);
 iframe_browse.contentWindow.document.close();
 });
 }
 } finally {
 // Clean up the remaining code
 mainWebRCodeShelter.purge();
 }
};

// Function to execute the code (accepts code as an argument)
globalThis.qwebrExecuteCode = async function (
 codeToRun,
 id,
 options = {}) {

 // If options are not passed, we fall back on the bare minimum to handle the computation
 if (qwebrIsObjectEmpty(options)) {
 options = {
 "context": "interactive",
 "fig-width": 7, "fig-height": 5,
 "out-width": "700px", "out-height": "",
 "dpi": 72,
 "results": "markup",
 "warning": "true", "message": "true",
 };
 }

 // Next, we access the compute areas values
 const elements = {
 runButton: document.getElementById(`qwebr-button-run-${id}`),
 outputCodeDiv: document.getElementById(`qwebr-output-code-area-${id}`),
 outputGraphDiv: document.getElementById(`qwebr-output-graph-area-${id}`),
 id: id,
 }

 // Disallowing execution of other code cells
 document.querySelectorAll(".qwebr-button-run").forEach((btn) => {
 btn.disabled = true;
 });

 if (options.context == EvalTypes.Interactive) {
 // Emphasize the active code cell
 elements.runButton.innerHTML = ' Run Code';
 }

 // Evaluate the code and parse the output into the document
 await qwebrComputeEngine(codeToRun, elements, options);

 // Switch to allowing execution of code
 document.querySelectorAll(".qwebr-button-run").forEach((btn) => {
 btn.disabled = false;
 });

 if (options.context == EvalTypes.Interactive) {
 // Revert to the initial code cell state
 elements.runButton.innerHTML = ' Run Code';
 }
}



  // Configure the Monaco Editor's loader
  require.config({
    paths: {
      'vs': 'https://cdn.jsdelivr.net/npm/monaco-editor@0.47.0/min/vs'
    }
  });



// Function to update Monaco Editors when body class changes
function updateMonacoEditorsOnBodyClassChange() {
    // Select the body element
    const body = document.querySelector('body');

    // Options for the observer (which mutations to observe)
    const observerOptions = {
        attributes: true,  // Observe changes to attributes
        attributeFilter: ['class'] // Only observe changes to the 'class' attribute
    };

    // Callback function to execute when mutations are observed
    const bodyClassChangeCallback = function(mutationsList, observer) {
        for(let mutation of mutationsList) {
            if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
                // Class attribute has changed
                // Update all Monaco Editors on the page
                updateMonacoEditorTheme();
            }
        }
    };

    // Create an observer instance linked to the callback function
    const observer = new MutationObserver(bodyClassChangeCallback);

    // Start observing the target node for configured mutations
    observer.observe(body, observerOptions);
}

// Function to update all instances of Monaco Editors on the page
function updateMonacoEditorTheme() {
    // Determine what VS Theme to use
    const vsThemeToUse = document.body.classList.contains("quarto-dark") ? 'vs-dark' : 'vs' ;

    // Iterate through all initialized Monaco Editors
    qwebrEditorInstances.forEach( function(editorInstance) { 
        editorInstance.updateOptions({ theme: vsThemeToUse }); 
    });
}

// Call the function to start observing changes to body class
updateMonacoEditorsOnBodyClassChange();


// Global array to store Monaco Editor instances
globalThis.qwebrEditorInstances = [];

function isValidCodeLineNumbers(stringCodeLineNumbers) {
 // Regular expression to match valid input strings
 const regex = /^(\d+(-\d+)?)(,\d+(-\d+)?)*$/;
 return regex.test(stringCodeLineNumbers);
}

// Function that builds and registers a Monaco Editor instance 
globalThis.qwebrCreateMonacoEditorInstance = function (cellData) {

 const initialCode = cellData.code;
 const qwebrCounter = cellData.id;
 const qwebrOptions = cellData.options;

 // Retrieve the previously created document elements
 let runButton = document.getElementById(`qwebr-button-run-${qwebrCounter}`);
 let resetButton = document.getElementById(`qwebr-button-reset-${qwebrCounter}`);
 let copyButton = document.getElementById(`qwebr-button-copy-${qwebrCounter}`);
 let editorDiv = document.getElementById(`qwebr-editor-${qwebrCounter}`);

 // Load the Monaco Editor and create an instance
 let editor;
 require(['vs/editor/editor.main'], function () {
 editor = monaco.editor.create(editorDiv, {
 value: initialCode,
 language: 'r',
 theme: 'vs-light',
 automaticLayout: true, // Works wonderfully with RevealJS
 scrollBeyondLastLine: false,
 minimap: {
 enabled: false
 },
 fontSize: qwebrScaledFontSize(editorDiv, qwebrOptions), 
 renderLineHighlight: "none", // Disable current line highlighting
 hideCursorInOverviewRuler: true, // Remove cursor indictor in right hand side scroll bar
 readOnly: qwebrOptions['read-only'] ?? false,
 quickSuggestions: qwebrOptions['editor-quick-suggestions'] ?? false,
 wordWrap: (qwebrOptions['editor-word-wrap'] == 'true' ? "on" : "off")
 });

 // Store the official counter ID to be used in keyboard shortcuts
 editor.__qwebrCounter = qwebrCounter;

 // Store the official div container ID
 editor.__qwebrEditorId = `qwebr-editor-${qwebrCounter}`;

 // Store the initial code value and options
 editor.__qwebrinitialCode = initialCode;
 editor.__qwebrOptions = qwebrOptions;

 // Set at the model level the preferred end of line (EOL) character to LF.
 // This prevent `\r\n` from being given to the webR engine if the user is on Windows.
 // See details in: https://github.com/coatless/quarto-webr/issues/94
 // Associated error text: 
 // Error: <text>:1:7 unexpected input

 // Retrieve the underlying model
 const model = editor.getModel();
 // Set EOL for the model
 model.setEOL(monaco.editor.EndOfLineSequence.LF);
 
 // Dynamically modify the height of the editor window if new lines are added.
 let ignoreEvent = false;
 const updateHeight = () => {
 // Increment editor height by 2 to prevent vertical scroll bar from appearing
 const contentHeight = editor.getContentHeight() + 2;

 // Retrieve editor-max-height option
 const maxEditorHeight = qwebrOptions['editor-max-height'];

 // If editor-max-height is missing, allow infinite growth. Otherwise, threshold.
 const editorHeight = !maxEditorHeight ? contentHeight : Math.min(contentHeight, maxEditorHeight);

 // We're avoiding a width change
 //editorDiv.style.width = `${width}px`;
 editorDiv.style.height = `${editorHeight}px`;
 try {
 ignoreEvent = true;

 // The key to resizing is this call
 editor.layout();
 } finally {
 ignoreEvent = false;
 }
 };

 // Function to generate decorations to highlight lines
 // in the editor based on input string.
 function decoratorHighlightLines(codeLineNumbers) {
 // Store the lines to be lighlight
 let linesToHighlight = [];
 
 // Parse the codeLineNumbers string to get the line numbers to highlight
 // First, split the string by commas
 codeLineNumbers.split(',').forEach(part => {
 // Check if we have a range of lines
 if (part.includes('-')) {
 // Handle range of lines (e.g., "6-8")
 const [start, end] = part.split('-').map(Number);
 for (let i = start; i <= end; i++) {
 linesToHighlight.push(i);
 }
 } else {
 // Handle single line (e.g., "7")
 linesToHighlight.push(Number(part));
 }
 });
 
 // Create monaco decorations for the lines to highlight
 const decorations = linesToHighlight.map(lineNumber => ({
 range: new monaco.Range(lineNumber, 1, lineNumber, 1),
 options: {
 isWholeLine: true,
 className: 'qwebr-editor-highlight-line'
 }
 }));
 
 // Return decorations to be applied to the editor
 return decorations;
 }

 // Ensure that the editor-code-line-numbers option is set and valid
 // then apply styling
 if (qwebrOptions['editor-code-line-numbers']) {
 // Remove all whitespace from the string
 const codeLineNumbers = qwebrOptions['editor-code-line-numbers'].replace(/\s/g,'');
 // Check if the string is valid for line numbers, e.g., "1,3-5,7"
 if (isValidCodeLineNumbers(codeLineNumbers)) {
 // Apply the decorations to the editor
 editor.createDecorationsCollection(decoratorHighlightLines(codeLineNumbers));
 } else {
 // Warn the user that the input is invalid
 console.warn(`Invalid "editor-code-line-numbers" value in code cell ${qwebrOptions['label']}: ${codeLineNumbers}`);
 }
 }

 // Helper function to check if selected text is empty
 function isEmptyCodeText(selectedCodeText) {
 return (selectedCodeText === null || selectedCodeText === undefined || selectedCodeText === "");
 }

 // Registry of keyboard shortcuts that should be re-added to each editor window
 // when focus changes.
 const addWebRKeyboardShortCutCommands = () => {
 // Add a keydown event listener for Shift+Enter to run all code in cell
 editor.addCommand(monaco.KeyMod.Shift | monaco.KeyCode.Enter, () => {

 // Retrieve all text inside the editor
 qwebrExecuteCode(editor.getValue(), editor.__qwebrCounter, editor.__qwebrOptions);
 });

 // Add a keydown event listener for CMD/Ctrl+Enter to run selected code
 editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter, () => {

 // Get the selected text from the editor
 const selectedText = editor.getModel().getValueInRange(editor.getSelection());
 // Check if no code is selected
 if (isEmptyCodeText(selectedText)) {
 // Obtain the current cursor position
 let currentPosition = editor.getPosition();
 // Retrieve the current line content
 let currentLine = editor.getModel().getLineContent(currentPosition.lineNumber);

 // Propose a new position to move the cursor to
 let newPosition = new monaco.Position(currentPosition.lineNumber + 1, 1);

 // Check if the new position is beyond the last line of the editor
 if (newPosition.lineNumber > editor.getModel().getLineCount()) {
 // Add a new line at the end of the editor
 editor.executeEdits("addNewLine", [{
 range: new monaco.Range(newPosition.lineNumber, 1, newPosition.lineNumber, 1),
 text: "\n", 
 forceMoveMarkers: true,
 }]);
 }
 
 // Run the entire line of code.
 qwebrExecuteCode(currentLine, editor.__qwebrCounter, editor.__qwebrOptions);

 // Move cursor to new position
 editor.setPosition(newPosition);
 } else {
 // Code to run when Ctrl+Enter is pressed with selected code
 qwebrExecuteCode(selectedText, editor.__qwebrCounter, editor.__qwebrOptions);
 }
 });
 }

 // Register an on focus event handler for when a code cell is selected to update
 // what keyboard shortcut commands should work.
 // This is a workaround to fix a regression that happened with multiple
 // editor windows since Monaco 0.32.0 
 // https://github.com/microsoft/monaco-editor/issues/2947
 editor.onDidFocusEditorText(addWebRKeyboardShortCutCommands);

 // Register an on change event for when new code is added to the editor window
 editor.onDidContentSizeChange(updateHeight);

 // Manually re-update height to account for the content we inserted into the call
 updateHeight();

 // Store the editor instance in the global dictionary
 qwebrEditorInstances[editor.__qwebrCounter] = editor;

 });

 // Add a click event listener to the run button
 runButton.onclick = function () {
 qwebrExecuteCode(editor.getValue(), editor.__qwebrCounter, editor.__qwebrOptions);
 };

 // Add a click event listener to the reset button
 copyButton.onclick = function () {
 // Retrieve current code data
 const data = editor.getValue();
 
 // Write code data onto the clipboard.
 navigator.clipboard.writeText(data || "");
 };
 
 // Add a click event listener to the copy button
 resetButton.onclick = function () {
 editor.setValue(editor.__qwebrinitialCode);
 };
 
}

// Handle cell initialization initialization
qwebrCellDetails.map(
 (entry) => {
 // Handle the creation of the element
 qwebrCreateHTMLElement(entry);
 // In the event of interactive, initialize the monaco editor
 if (entry.options.context == EvalTypes.Interactive) {
 qwebrCreateMonacoEditorInstance(entry);
 }
 }
);

// Identify non-interactive cells (in order)
const filteredEntries = qwebrCellDetails.filter(entry => {
 const contextOption = entry.options && entry.options.context;
 return ['output', 'setup'].includes(contextOption) || (contextOption == "interactive" && entry.options && entry.options.autorun === 'true');
});

// Condition non-interactive cells to only be run after webR finishes its initialization.
qwebrInstance.then(
 async () => {
 const nHiddenCells = filteredEntries.length;
 var currentHiddenCell = 0;


 // Modify button state
 qwebrSetInteractiveButtonState(`🟡 Running hidden code cells ...`, false);

 // Begin processing non-interactive sections
 // Due to the iteration policy, we must use a for() loop.
 // Otherwise, we would need to switch to using reduce with an empty
 // starting promise
 for (const entry of filteredEntries) {

 // Determine cell being examined
 currentHiddenCell = currentHiddenCell + 1;
 const formattedMessage = `Evaluating hidden cell ${currentHiddenCell} out of ${nHiddenCells}`;

 // Update the document status header
 if (qwebrShowStartupMessage) {
 qwebrUpdateStatusHeader(formattedMessage);
 }

 // Display the update in non-active areas
 qwebrUpdateStatusMessage(formattedMessage);

 // Extract details on the active cell
 const evalType = entry.options.context;
 const cellCode = entry.code;
 const qwebrCounter = entry.id;

 if (['output', 'setup'].includes(evalType)) {
 // Disable further global status updates
 const activeContainer = document.getElementById(`qwebr-non-interactive-loading-container-${qwebrCounter}`);
 activeContainer.classList.remove('qwebr-cell-needs-evaluation');
 activeContainer.classList.add('qwebr-cell-evaluated');

 // Update status on the code cell
 const activeStatus = document.getElementById(`qwebr-status-text-${qwebrCounter}`);
 activeStatus.innerText = " Evaluating hidden code cell...";
 activeStatus.classList.remove('qwebr-cell-needs-evaluation');
 activeStatus.classList.add('qwebr-cell-evaluated');
 }

 switch (evalType) {
 case 'interactive':
 // TODO: Make this more standardized.
 // At the moment, we're overriding the interactive status update by pretending its
 // output-like. 
 const tempOptions = entry.options;
 tempOptions["context"] = "output"
 // Run the code in a non-interactive state that is geared to displaying output
 await qwebrExecuteCode(`${cellCode}`, qwebrCounter, tempOptions);
 break;
 case 'output':
 // Run the code in a non-interactive state that is geared to displaying output
 await qwebrExecuteCode(`${cellCode}`, qwebrCounter, entry.options);
 break;
 case 'setup':
 const activeDiv = document.getElementById(`qwebr-noninteractive-setup-area-${qwebrCounter}`);

 // Store code in history
 qwebrLogCodeToHistory(cellCode, entry.options);

 // Run the code in a non-interactive state with all output thrown away
 await mainWebR.evalRVoid(`${cellCode}`);
 break;
 default: 
 break; 
 }

 if (['output', 'setup'].includes(evalType)) {
 // Disable further global status updates
 const activeContainer = document.getElementById(`qwebr-non-interactive-loading-container-${qwebrCounter}`);
 // Disable visibility
 activeContainer.style.visibility = 'hidden';
 activeContainer.style.display = 'none';
 }
 }
 }
).then(
 () => {
 // Release document status as ready

 if (qwebrShowStartupMessage) {
 qwebrStartupMessage.innerText = "🟢 Ready!"
 }
 
 qwebrSetInteractiveButtonState(
 ` Run Code`, 
 true
 ); 
 }
);

Requests	IP Address	Location	AS Autonomous System
11	104.17.25.14	United States	AS13335Cloudflare, Inc.
6	192.178.183.94	United States	AS15169Google LLC
6	172.217.17.202	United States	AS15169Google LLC
6	188.114.97.3	United States	AS13335Cloudflare, Inc.
6	13.32.99.61	New York, New York, United States	AS16509Amazon.com, Inc.
6	104.16.175.226	United States	AS13335Cloudflare, Inc.
41	6	-	-

Security Scan Report: auds-r-dev.pages.dev

Summary

AI Security Verdict

Low Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies5

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History