function toggleNextSibling (e) {
							if (e.nextSibling.style.display=='none') {
							e.nextSibling.style.display='block';
							} else { e.nextSibling.style.display='none'; }
							}
      // Globals used by SEC loader (Show.js)
      window.SEC_ALIAS_DIR = "";
      window.RFV_MENU = [{"category":"Cover","reports":[{"label":"Submission","pos":1,"url":"R1.htm"},{"label":"Offerings","pos":2,"url":"R2.htm"},{"label":"Fees Summary","pos":3,"url":"R3.htm"}]},{"allReports":{"1":"R1.htm","2":"R2.htm","3":"R3.htm","4":"ALL_REPORTS_SYNTHETIC"}}];
      window.R_FILES_BY_POS = RFV_MENU.find(o => 'allReports' in o)?.allReports;
      function scrollMainContentToTop() {
        // Scroll to company info instead of top of page header
        const anchor = document.getElementById('company-info');
        if (anchor) {
          anchor.scrollIntoView({
            block: 'start',   // top-align it
            behavior: 'auto'  // no animation unless desired
          });
        }
      }
      
      
      window.RENDERING_LOGS = RFV_MENU.find(o => 'renderingLogs' in o)?.renderingLogs;
      // Log viewer renders selected log into #reportDiv
      window.showRenderingLog = function () {
        const root = ensureShadow();
        clearShadow();

        let baseDir = (typeof window.SEC_ALIAS_DIR === 'string' && window.SEC_ALIAS_DIR.length)
          ? window.SEC_ALIAS_DIR.replace(/\/$/, '')
          : (location.pathname.replace(/\/[^/]*$/, '') || '/');
        if (!baseDir.endsWith('/')) baseDir += '/';

        const reportCssHref = `${baseDir}report.css`; // same folder as R1.htm

        const logEntries = window.RENDERING_LOGS || [];
        const rows = logEntries.map(entry => {
          const type = entry?.type || 'Info';
          const text = (entry?.text || '').replace(/\r\n|\r|\n/g, '<br>');
          const cls  = type.slice(0,4).toLowerCase(); // 'erro', 'warn', 'info', etc.
          return `<tr class="ro"><td class="text ${cls}">${type}: ${text}</td></tr>`;
        }).join('');

        const container = document.createElement('div');
        container.id = 'rfv-shadow-host';
        container.innerHTML = `
          <style>
            /* Pull in full report stylesheet for consistent table look */
            @import url("${reportCssHref}");

            /* Minimal extras for log highlighting */
            .info { }
            .erro { background-color: pink; }
            .inco { background-color: peachpuff; }
            .warn { background-color: lemonchiffon; }

            table.report { width: auto; max-width: 100%; border-collapse: collapse; }
        h2 { font-family: sans-serif; }
          </style>
          <h2>Rendering Log</h2>
          <table class="report" border="0" cellspacing="2" role="table">
            <tbody>
              <tr><th class="Info">The rendering log information below will not appear on the EDGAR web site.</th></tr>
              ${rows}
            </tbody>
          </table>
        `;
        root.appendChild(container);
        scrollMainContentToTop();
      };
      function decodeHtmlEntities(s) {
        // safest cross-browser decode
        const t = document.createElement('textarea');
        t.innerHTML = s;
        return t.value;
      }

      function decodeBase64Utf8(b64) {
        const bin = atob(b64);
        const bytes = Uint8Array.from(bin, c => c.charCodeAt(0));
        return new TextDecoder("utf-8").decode(bytes);
      }

      function sanitizeId(id) {
        return id.replace(/[^a-zA-Z0-9\._-]/g, '_'); // Replace invalid chars with underscore
      }

      /**
       * Normalize raw report HTML for extraction across contexts:
       * - SECWS: decode entity-escaped HTML (&lt;html&gt; → <html>)
       * - sec.gov SGML: keep full <head> and <body>, unwrap <TEXT>…</TEXT> safely
       * - Arelle/plain: pass through unchanged
       */
      function normalizeReportHtml(raw) {
        let src = String(raw || '');

        // If looks entity-escaped (e.g., &lt;html>, &lt;TEXT>, etc.), decode first
        const looksEscaped = /&lt;\/?(?:html|head|body|TEXT)\b/i.test(src) || /&lt;[a-z]/i.test(src);
        if (looksEscaped) {
          try { src = decodeHtmlEntities(src); } catch (_) {}
        }

        // If wrapped in SGML <TEXT>…</TEXT>, unwrap while preserving <head>
        const hasSGML = /<TEXT>/i.test(src) && /<\/TEXT>/i.test(src);
        if (hasSGML) {
          const start = src.search(/<TEXT>/i);
          const end   = src.search(/<\/TEXT>/i);
          if (start !== -1 && end !== -1 && end > start) {
            src = src.slice(start + '<TEXT>'.length, end);
          }
        }

        return src;
      }

      function ensureShadow() {
        const pane = document.getElementById('reportDiv');
        if (!pane) return null;
        if (!pane.shadowRoot) pane.attachShadow({ mode: 'open' });
        // mirror for any legacy code still reading _shadowRoot
        pane._shadowRoot = pane.shadowRoot;
        // make sure host is visible and not contained
        pane.hidden = false;
        pane.style.display = 'block';
        pane.style.visibility = 'visible';
        pane.style.contain = 'none';
        return pane.shadowRoot;
      }

      function clearShadow() {
        const root = ensureShadow();
        if (root) root.innerHTML = '';
      }

      function renderIntoShadow(bodyHtml, links, inlineStyles, baseDir) {
        const root = ensureShadow();
        if (!root) return;

        // Always clear previous report
        clearShadow();


        // pane fades via .rfv-pending; do not change visibility to avoid header repaint
        const pane = document.getElementById('reportDiv');

        // 1) Inline styles FIRST for immediate styling
        if (Array.isArray(inlineStyles)) {
          for (const css of inlineStyles) {
            if (css) {
              const styleEl = document.createElement('style');
              styleEl.textContent = css;
              root.appendChild(styleEl);
            }
          }
        }

        // 2) Safety constraints (layout)
        const safety = document.createElement('style');
        safety.textContent = `
          :host { display:block; width:auto; max-width:100%; }
          #rfv-shadow-host { display:block; width:auto; max-width:100%; overflow:visible; }
          table.report { width:auto; max-width:100%; border-collapse: collapse; }
          img { max-width:100%; height:auto; }

          /* Unbeatable forced ring (wins against report CSS with !important resets) */
          .rfv-force-focus,
          .rfv-focus-ring {
            outline: 3px solid #005A9C !important;
            outline-offset: 2px !important;
            box-shadow: 0 0 0 2px #fff inset !important;
          }
          :focus-visible {
            outline: 3px solid #005A9C !important;
            outline-offset: 2px !important;
          }
          `;
        root.appendChild(safety);

        // 3) Report body
        const container = document.createElement('div');
        container.id = 'rfv-shadow-host';
        container.innerHTML = bodyHtml;        
        container.setAttribute('tabindex', '-1');       // make container focusable
        container.setAttribute('role', 'region');       // semantic region
        container.setAttribute('aria-label', 'All reports content'); // accessible name
        root.appendChild(container);

        // 4) External CSS: fetch-and-prepend, with <link> fallback
        const loadExternalCss = () => {
          if (!Array.isArray(links) || !links.length) return Promise.resolve();
          // some old R files have css includes to include/report.css but there is no include subdirectory
          const absHrefs = links.map(h =>
            h.startsWith('/')                 // absolute → leave unchanged
              ? h
              : h.startsWith('include/')      // legacy relative include/
                ? `${baseDir}${h.slice(8)}`
                : `${baseDir}${h}`           // standard relative report.css, etc.
          );

          return Promise.allSettled(
            absHrefs.map(h => fetch(h).then(r => (r.ok ? r.text() : '')))
          ).then(results => {
            const cssText = results
              .filter(r => r.status === 'fulfilled' && r.value)
              .map(r => normalizeReportHtml(r.value))
              .join('\n');
            const styles = document.createElement('style');
            styles.textContent =
              cssText && cssText.length
                ? cssText
                : absHrefs.map(h => `@import url("${h}");`).join('\n');
            root.insertBefore(styles, root.firstChild);
          });
        };

        // Resolve after external CSS is ready (if any)
        return loadExternalCss();

      }

      // Cache of styles we've already loaded
      const RFV_LOADED_STYLES = new Set();

      function extractLinksAndBody(fullHtml) {
        const doc = new DOMParser().parseFromString(fullHtml, 'text/html');

        // External CSS links (e.g., <link rel="stylesheet" href="report.css">)
        const links = Array.from(doc.querySelectorAll('link[rel~="stylesheet"][href]'))
          .map(link => (link.getAttribute('href') || '').trim())
          .filter(Boolean);

        // Inline <style> blocks (Arelle & some SEC variants)
        const inlineStyles = Array.from(doc.querySelectorAll('style'))
          .map(style => style.textContent || '')
          .filter(Boolean);

        // Body HTML
        const bodyHtml = doc.body ? doc.body.innerHTML : fullHtml;

        return { links, inlineStyles, bodyHtml };
      }

      window.loadReport = async function (n, scrollToMainContent=true) {
        const files = window.R_FILES_BY_POS || {};
        const file = files[n];
        const pane = document.getElementById('reportDiv');
        if (!pane) return;

        pane.setAttribute('aria-busy', 'true');
        pane.classList.add('rfv-pending');
        pane.classList.add('rfv-hide-until-styled'); // hide now, before Shadow DOM is touched
        if (window.RFV && RFV.showLoadingOverlay) {
          window.RFV_SPINNER_TIMER = setTimeout(() => {
            if (window.RFV && RFV.showLoadingOverlay)
              RFV.showLoadingOverlay();
          }, 150);
        }

        if (!file) {
          pane.classList.remove('rfv-pending');
          pane.classList.remove('rfv-hide-until-styled');
          pane.removeAttribute('aria-busy');
          return;
        }

        let baseDir = (typeof window.SEC_ALIAS_DIR === 'string' && window.SEC_ALIAS_DIR.length)
          ? window.SEC_ALIAS_DIR.replace(/\/$/, '')
          : (location.pathname.replace(/\/[^/]*$/, '/') || '/');
        if (!baseDir.endsWith('/')) baseDir += '/';
        const rXtoH = (window.TRANSFORMED_HTML_REPORTS || {}); // present only for Xml R files transformed to html by server

        // --- Synthetic "All Reports": render all into shadow, no light-DOM writes ---
        if (file === 'ALL_REPORTS_SYNTHETIC') {
          const keys = Object.keys(files).map(Number).sort((a, b) => a - b);
          clearShadow();
          const root = ensureShadow();

          // SAFETY STYLES (same as single-report path): ensures forced ring + keyboard ring
          const safety = document.createElement('style');
          safety.textContent = `
            :host { display:block; width:auto; max-width:100%; }
            #rfv-shadow-host { display:block; width:auto; max-width:100%; overflow:visible; }
            table.report { width:auto; max-width:100%; border-collapse: collapse; }
            img { max-width:100%; height:auto; }

            /* Unbeatable forced ring (wins against report CSS with !important resets) */
            .rfv-force-focus,
            .rfv-focus-ring {
              outline: 3px solid #005A9C !important;
              outline-offset: 2px !important;
              box-shadow: 0 0 0 2px #fff inset !important;
            }
            /* Keyboard ring inside Shadow DOM (helpful when not forcing) */
            :focus-visible {
              outline: 3px solid #005A9C !important;
              outline-offset: 2px !important;
            }
          `;
          root.appendChild(safety);

          const container = document.createElement('div');
          container.id = 'rfv-shadow-host';
          container.setAttribute('tabindex', '-1');            // focusable region in Shadow DOM
          container.setAttribute('role', 'region');            // semantics for SRs
          container.setAttribute('aria-label', 'All reports content');
          root.appendChild(container);

          (async function fetchAll(i) {
            if (i >= keys.length) {
              pane.classList.remove('rfv-pending');
              pane.removeAttribute('aria-busy');
              // Clear ARIA status now that all reports have loaded
              if (RFV.announceStatus)
                RFV.announceStatus("");
              if (window.RFV && RFV.hideLoadingOverlay) {
                clearTimeout(window.RFV_SPINNER_TIMER);
                RFV.hideLoadingOverlay();
              }
              requestAnimationFrame(() => {
                if (window.RFV && typeof RFV.focusContentFirst === "function") {
                    RFV.focusContentFirst({ forceVisible: true });
                    setTimeout(() => RFV.focusContentFirst({ forceVisible: true }), 0);
                }
              });
              __rfvRevealWhenFirstReportDone();
              return;
            }
            const k = keys[i], f2 = files[k];
            if (f2 === 'ALL_REPORTS_SYNTHETIC') return fetchAll(i + 1);

            try {
              let rHtml;
              if (rXtoH && typeof rXtoH[k] === 'string' && rXtoH[k].length) {
                rHtml = decodeBase64Utf8(rXtoH[k]); // use server-transformed HTML
              } else {
                const url = `${baseDir}${f2}`;
                const rawHtml = await fetch(url).then(r => r.text());
                rHtml = normalizeReportHtml(rawHtml);
              }
              ({ links, inlineStyles, bodyHtml } = extractLinksAndBody(rHtml));
              const bodyHtmlImgsFixed = rewriteRelativeImgSrcsAndIdsInHtml(bodyHtml, baseDir);

              // Immediately style this section with its inline <style> blocks
              if (inlineStyles && inlineStyles.length) {
                const inline = document.createElement('style');
                inline.textContent = inlineStyles.join('\n');
                root.insertBefore(inline, root.firstChild);
              }

              const section = document.createElement('section');
              section.innerHTML = bodyHtmlImgsFixed;
              container.appendChild(section);
              if (i < keys.length - 2) // horiz rule after all but last report
                container.appendChild(document.createElement('hr'));

              // External CSS for the section
              if (links && links.length) {
                const abs = links.map(h => 
                    h.startsWith('/')                 // absolute → leave unchanged
                      ? h
                      : h.startsWith('include/')      // legacy relative include/
                        ? `${baseDir}${h.slice(8)}`
                        : `${baseDir}${h}`           // standard relative report.css, etc.
                );
                Promise.allSettled(abs.map(h => fetch(h).then(r => r.ok ? r.text() : ''))).then(res => {
                  const cssText = res.filter(r => r.status === 'fulfilled' && r.value)
                                    .map(r => normalizeReportHtml(r.value)).join('\n');
                  if (cssText) {
                    const styleEl = document.createElement('style');
                    styleEl.textContent = cssText;
                    root.insertBefore(styleEl, root.firstChild); // prepend at root for cascade
                  } else {
                    // Fallback: load external CSS via @import inside a <style> (works in ShadowRoot)
                    const importStyle = document.createElement('style');
                    importStyle.textContent = `@import url("${abs[0]}");`;
                    root.insertBefore(importStyle, root.firstChild);
                  }
                  pane.classList.remove('rfv-hide-until-styled');

                });
              }
            } catch (e) {
              const err = document.createElement('div');
              err.setAttribute('role', 'alert');
              err.style.color = 'red';
              err.textContent = `Failed to load ${url}`;
              container.appendChild(err);
            }
            fetchAll(i + 1);
          })(0);

          return; // done
        }

        // --- Single report: render shadow first, then css ---

        try {
          // rXtoH: map of Base64-encoded HTML for transformed XML reports, e.g. window.TRANSFORMED_HTML_REPORTS_BASE64
          // files: map of position -> filename (e.g. R1.htm or R2.xml)
          // n: position (number), file: files[n], baseDir: previously computed

          let rHtml;                      // unified HTML string, regardless of source
          let links = [];                 // collect <link rel="stylesheet"> hrefs
          let inlineStyles = [];          // collect inline <style> blocks
          let bodyHtml = '';              // extracted body innerHTML

          // 1) Resolve HTML: prefer server-transformed XML (Base64), otherwise fetch .htm
          const isServerTransformed = !!(rXtoH && typeof rXtoH[n] === 'string' && rXtoH[n].length);
          if (isServerTransformed) {
            // Decode UTF‑8 Base64 safely to avoid mojibake
            rHtml = decodeBase64Utf8(rXtoH[n]);
          } else {
            const url = `${baseDir}${file}`;
            const rawHtml = await fetch(url).then(r => r.text());
            rHtml = normalizeReportHtml(rawHtml); // unwrap SGML <TEXT>…</TEXT> etc.
          }

          // 2) Extract CSS links, inline styles, and body HTML
          ({ links, inlineStyles, bodyHtml } = extractLinksAndBody(rHtml));

          // 3) Pre‑rewrite relative <img src> BEFORE insertion to prevent early 404s
          const bodyHtmlImgsFixed = rewriteRelativeImgSrcsAndIdsInHtml(bodyHtml, baseDir);

          // 4) Single-report render into ShadowRoot (uniform for XML and HTM)
          await renderIntoShadow(bodyHtmlImgsFixed, links, inlineStyles, baseDir);

          // CSS is applied; reveal pane and clear pending state
          pane.classList.remove('rfv-hide-until-styled');
          pane.classList.remove('rfv-pending');
          pane.removeAttribute('aria-busy');
        } catch (e) {
          pane.innerHTML = '<div role="alert" style="color:red;">Failed to load report.</div>';

          // Ensure we still clear pending on error
          pane.classList.remove('rfv-hide-until-styled');
          pane.classList.remove('rfv-pending');
          pane.removeAttribute('aria-busy');
        } finally {
          pane.classList.remove('rfv-pending');
          pane.removeAttribute('aria-busy');

          const byMouse = !!window.RFV_FORCE_VISIBLE_ON_OPEN;

          // Only scroll when it was mouse‑initiated AND caller asked to scroll
          if (scrollToMainContent && byMouse) {
            window.scrollTo(0,0);   // Prior PERL behavior, or scrollMainContentToTop(); to scroll to top of content area
          }

          // Move focus into content; force visible ring only if opening was mouse-initiated
          const forceVisible = !!window.RFV_FORCE_VISIBLE_ON_OPEN;
          window.RFV_FORCE_VISIBLE_ON_OPEN = false;

          if (window.RFV && typeof RFV.focusContentFirst === 'function') {
            RFV.focusContentFirst({ forceVisible });
          }

          // Clear ARIA status once single report finishes loading
          if (RFV.announceStatus)
            RFV.announceStatus("");
          if (window.RFV && RFV.hideLoadingOverlay) {
            clearTimeout(window.RFV_SPINNER_TIMER);
            RFV.hideLoadingOverlay();
          }
          __rfvRevealWhenFirstReportDone();
        }
        return; // done

      };


      // Page readiness toggles to prevent FOUC
      function __rfvSetReady() {
        const doc = document.documentElement;
        doc.classList.remove('rfv-loading');
        doc.classList.add('rfv-ready');
      }

      function __rfvRevealWhenFirstReportDone() {
        // called after report has rendered and external CSS (if any) is processed
        __rfvSetReady();
      }

      // --- XML detection & transformation helpers ---

      function looksXmlContent(txt) {
        const s = String(txt || '').trim();
        // conservative sniff: XML declaration OR presence of '<xbrl' or '<Report' without '<html'
        return /^<\?xml/i.test(s) || (/<xbrl\b/i.test(s) || /<Report\b/i.test(s)) && !/<html\b/i.test(s);
      }

      function isXmlFileName(name) {
        return typeof name === 'string' && /.xml$/i.test(name);
      }

      async function fetchXslt(url) {
        const r = await fetch(url);
        if (!r.ok) throw new Error('XSLT fetch failed');
        return await r.text();
      }

      function parseXml(text) {
        return new DOMParser().parseFromString(text, 'text/xml');
      }

      // Port of legacy fixSrcAttr, adapted to ShadowRoot
      function fixImageSrcsInside(root, baseDir) {
        const imgs = root.querySelectorAll('img[src]');
        imgs.forEach(img => {
          const src = (img.getAttribute('src') || '').trim();
          if (!src || src.startsWith('data:')) return;
          if (src.startsWith('https://s3.amazonaws.com/')) return;
          // Take basename and prefix with baseDir
          const idx = src.lastIndexOf('/');
          const basename = idx >= 0 ? src.slice(idx + 1) : src;
          img.setAttribute('src', `${baseDir}${basename}`);
        });
      }

      // Port of FixNotesForGeckoWebkit
      function fixNotesForGeckoWebkit(container) {
        const tables = container.querySelectorAll('table');
        tables.forEach(t => {
          const cells = t.querySelectorAll('td.text');
          cells.forEach(td => {
            // If the cell is basically text that looks like HTML, turn it into HTML
            if (!td.querySelector('*')) {
              const text = td.textContent || '';
              if (/<\/?[a-zA-Z]\w*[^>]*>/.test(text)) {
                td.innerHTML = text;
              }
            }
          });
        });
      }

      function rewriteRelativeImgSrcsAndIdsInHtml(html, baseDir) {
        // Parse as HTML so we can adjust <img src> and ids before insertion
        const doc = new DOMParser().parseFromString(html, 'text/html');

        // 1. Fix up the src path (existing behavior)
        doc.querySelectorAll('img[src]').forEach(img => {
          const src = (img.getAttribute('src') || '').trim();

          // Leave already-absolute or data URLs untouched
          if (!src || src.startsWith('data:') || /^https?:\/\//i.test(src) || src.startsWith('/')) return;

          // Preserve existing "include/" behavior if needed:
          // (old filings may have "include/report.css" for CSS; for images it is typically filename only)
          // For images that include a path, fold to basename:
          const idx = src.lastIndexOf('/');
          const basename = idx >= 0 ? src.slice(idx + 1) : src;

          // Rewrite to filing directory
          img.setAttribute('src', `${baseDir}${basename}`);

          // 2. Evaluate accessibility attributes
          const alt = (img.getAttribute('alt') || '').trim();
          const ariaLabel    = (img.getAttribute('aria-label') || '').trim();
          const ariaLabelled = (img.getAttribute('aria-labelledby') || '').trim();
          const title        = (img.getAttribute('title') || '').trim();

          // 3. Determine if this image is "non-informative" per accessibility rules
          const hasUsefulAlt =
            alt.length > 0 &&
            !/^(image|img|graphic|photo|picture)$/i.test(alt); // ignores meaningless alt values

          const hasAria = ariaLabel.length > 0 || ariaLabelled.length > 0;

          const hasTextAlternative =
            hasUsefulAlt ||
            hasAria ||
            title.length > 0;

          // 4. If *no* text alternative, treat as decorative
          if (!hasTextAlternative) {
            img.setAttribute('role', 'presentation');
            // Optionally ensure empty alt to comply with WCAG:
            if (!alt) img.setAttribute('alt', '');
          }
        });
        // 5. fix up table ids        
        doc.querySelectorAll('table[id]').forEach(table => {
          table.id = sanitizeId(table.id); // Implement sanitizeId as needed
        });
        

        // Return the body’s innerHTML to feed into ShadowRoot
        return doc.body ? doc.body.innerHTML : html;
      }

      // ---- R File Viewer (RFV) namespaced helpers ----
      // Accessible accordion + selection behavior, centralized here to avoid external includes.
      (function (win) {
        const RFV = win.RFV || (win.RFV = {});

        // Initialize the accordion menu (buttons with aria-expanded/aria-controls).
        RFV.initMenu = function () {
          const $menu = $('#menu');
          if (!$menu.length) return;

          // Hide panels and ensure ARIA state
          $menu.find('ul[data-accordion-panel]').each(function () {
            const $panel = $(this);
            if (!$panel.attr('id')) return;
            $panel.attr('hidden', true);
          });

          // Toggle (mouse)
          $menu.off('click.rfv').on('click.rfv', '.accordion-toggle', function () {
            const $btn = $(this);
            const panelId = $btn.attr('aria-controls');
            if (!panelId) return;
            const $panel = $('#' + panelId);
            const expanded = $btn.attr('aria-expanded') === 'true';
            $btn.attr('aria-expanded', String(!expanded));
            $panel.attr('hidden', expanded);
          });

          $menu.off('click.rfv.report').on('click.rfv.report', '.rf_viewer, .ix_viewer, .all_reports, .rendering_logs', function (e) {
            const $items = $menu.find('.rf_viewer, .ix_viewer, .all_reports, .rendering_logs');
            $items.removeClass('is-selected').attr('aria-current', null);
            $(this).addClass('is-selected').attr('aria-current', 'page');

            // Detect input modality: keyboard-triggered clicks (Enter/Space) vs mouse
            const byKeyboard = !!(e && e.originalEvent && (e.originalEvent instanceof KeyboardEvent));
            window.RFV_FORCE_VISIBLE_ON_OPEN = !byKeyboard; // true for mouse, false for keyboard

            // If this is an All Reports / Logs button, call the appropriate handler;
            // otherwise call loadReport() with its position.
            // If user clicked "All Reports", announce loading
            if (this.classList.contains('all_reports')) {
              if (window.RFV && RFV.announceStatus)
                RFV.announceStatus("Loading all reports… this may take several seconds.");
            }
          });

          // Keyboard support
          $menu.off('keydown.rfv').on('keydown.rfv', '.accordion-toggle', function (e) {
            if (e.key === ' ' || e.key === 'Enter') {
              e.preventDefault();
              $(this).trigger('click');
            }
          });

          // Auto-open first category on load
          const $firstToggle = $menu.find('.accordion-toggle').first();
          if ($firstToggle.length) {
            $firstToggle.attr('aria-expanded', 'true');
            const panelId = $firstToggle.attr('aria-controls');
            $('#' + panelId).attr('hidden', false);
          }
        };

        // Single, canonical highlight
        RFV.highlight = function (el) {
          const parent = document.getElementById('menu');
          if (!parent) return;
          const items = parent.querySelectorAll('.rf_viewer, .ix_viewer, .all_reports, .rendering_logs');
          items.forEach(function (node) {
            node.classList.remove('is-selected');
            node.removeAttribute('aria-current');
          });
          el.classList.add('is-selected');
          el.setAttribute('aria-current', 'page');
        };

        RFV.announceStatus = function (msg) {
          const el = document.getElementById('rfv-status');
          if (el) el.textContent = msg;
        };
        
        RFV.focusContentFirst = function (opts = {}) {
          const { forceVisible = false } = opts;
          const pane = document.getElementById('reportDiv');
          if (!pane) return;

          const sr = pane.shadowRoot || pane._shadowRoot || null;
          const CANDIDATE_A_ELTS = 'button, [role="button"], a[href], input, select, textarea, [tabindex]:not([tabindex="-1"])';

          let target = null;
          if (sr) {
            // step 1: query all focusable elements
            let focusables = [...sr.querySelectorAll(CANDIDATE_A_ELTS)];

            // step 2: filter by onclick containing "showAR"
            focusables = focusables.filter(el => {
              // onclick as attribute
              const onclickAttr = el.getAttribute('onclick') || '';
              if (onclickAttr.includes('showAR')) return true;

              // onclick as DOM property (JS-bound handlers)
              const onclickProp = el.onclick ? el.onclick.toString() : '';
              if (onclickProp.includes('showAR')) return true;

              return false;
            });
            // focus on the first matching one
            target = focusables[0];
          }
          
          if (!target && sr) {
            // 2) Shadow DOM fallback: the content container itself
            target = sr.getElementById('rfv-shadow-host');
            if (target && !target.hasAttribute('tabindex')) {
              target.setAttribute('tabindex', '-1');
            }
          }
          if (!target) {
            // 3) Light DOM fallback *only* if Shadow DOM isn’t available (rare)
            target = pane;
            if (!target.hasAttribute('tabindex')) target.setAttribute('tabindex', '-1');
          }

          if (target) {
            try {
              target.focus({ preventScroll: false });

              // If we want a visible ring for mouse users, add the temporary class.
              if (forceVisible) {
                target.classList.add('rfv-force-focus');
                // Remove the forced ring once the element loses focus.
                const cleanup = () => {
                  target.classList.remove('rfv-force-focus');
                  target.removeEventListener('blur', cleanup, true);
                };
                target.addEventListener('blur', cleanup, true);
              }
            } catch (_) {}
          }
        };

        RFV.showLoadingOverlay = function () {
          if (document.getElementById('rfv-loading-overlay')) return;
          const pane = document.getElementById('reportDiv');
          if (!pane) return;

          // Create overlay INSIDE the report pane
          const overlay = document.createElement('div');
          overlay.id = 'rfv-loading-overlay';
          overlay.className = 'rfv-loading-overlay';
          overlay.setAttribute('aria-hidden', 'true');
          overlay.innerHTML = '<div class="rfv-spinner" aria-hidden="true"></div>';

          // Ensure the pane defines a positioning context
          if (getComputedStyle(pane).position === 'static') {
            pane.style.position = 'relative';
          }
          pane.appendChild(overlay);
        };

        RFV.hideLoadingOverlay = function () {
          const overlay = document.getElementById('rfv-loading-overlay');
          if (overlay) overlay.remove();
        };

        // Publish Show into RFV namespace and as legacy global for backwards compatibility
        RFV.Show = win.Show = {
          lastAR: null,

          /**
           * Reveal a definition/reference popup:
           * 1) Find the next sibling panel OR
           * 2) Clone '#r' and insert just after 'a'.
           * Ensures visibility with 'hidden=false' and removes any 'display:none'.
           * Adds ARIA semantics, moves focus optionally.
           */
          showAR(a, r, w, opts = {}) {
            const {
              focus = true,
              label = 'Definition',
              selector = 'TABLE, DIV[data-def-panel], DIV.rfv-popup'
            } = opts;

            // Determine the host/root where the trigger lives
            const isShadow = !!a.getRootNode && a.getRootNode() instanceof ShadowRoot;
            const rootNode = isShadow ? a.getRootNode() : document;

            // Hide any previously shown panel
            if (Show.lastAR) Show.hideAR();

            // 1) Try to find an existing sibling panel within the same tree
            let panel = (function findNext(node, selector) {
              let e = node && node.nextSibling;
              while (e) {
                if (e.nodeType === Node.ELEMENT_NODE && e.matches && e.matches(selector)) return e;
                e = e.nextSibling;
              }
              return null;
            })(a, selector);

            // 2) Fallback: find referenced panel by id *inside the same tree* and clone it
            if (!panel && r) {
              let ref = null;
              const sanR = sanitizeId(r);
              try {
                if (isShadow) {
                  ref = rootNode.querySelector('#' + sanR);                // ShadowRoot lookup
                } else {
                  ref = rootNode.getElementById ? rootNode.getElementById(sanR) : document.getElementById(sanR);
                }
              } catch (e) {
                //console.log(`showAR ID not found: ${r}`);
                //console.log(`sanitized ID not found: ${sanR}`);
              }
              if (ref) {
                panel = ref.cloneNode(true);
                panel.removeAttribute('id');
                panel.classList.add('rfv-popup');
                // Insert the clone *after* the trigger, inside the same tree
                a.parentNode.insertBefore(panel, a.nextSibling);

                // Ensure popup CSS exists inside ShadowRoot if needed
                if (isShadow) {
                  const hasPopupCss = !!rootNode.querySelector('style[data-rfv-popup]');
                  if (!hasPopupCss) {
                    const styleEl = document.createElement('style');
                    styleEl.setAttribute('data-rfv-popup', 'true');
                    styleEl.textContent = `
                      .rfv-popup {
                        background-color: #def;
                        border: 2px solid #2F4497;
                        border-radius: 4px;
                        padding: 0;
                        margin: 0;
                        box-shadow: 0 2px 6px rgba(0,0,0,0.15);
                        z-index: 1000;
                      }
                      .rfv-popup [aria-expanded="false"]::before { content: "+ "; }
                      .rfv-popup [aria-expanded="true"]::before  { content: "- "; }
                      .rfv-popup[hidden] { display: none !important; }
                    `;
                    rootNode.appendChild(styleEl);
                  }
                }
              } else {
                console.log(`showAR reference not found: ${r}`);
              }
            }

            if (!panel) return;

            // Normalize AR labels (+/-)
            panel.querySelectorAll('a, button').forEach(el => {
              if (el.textContent && /^[+-]\s*/.test(el.textContent)) {
                el.textContent = el.textContent.replace(/^[+-]\s*/, '');
              }
            });

            // Initialize expanders for toggleNext
            panel.querySelectorAll('a[onclick*="toggleNext"], button[onclick*="toggleNext"]').forEach(el => {
              const controlled = (function findNextOfType(node, tagName) {
                let e = node && node.nextSibling;
                while (e) {
                  if (e.nodeType === Node.ELEMENT_NODE && e.nodeName === tagName) return e;
                  e = e.nextSibling;
                }
                return null;
              })(el, "DIV");
              if (controlled) {
                if (!controlled.id) controlled.id = (function genId(prefix = 'rfv-panel') {
                  const s = Date.now().toString(36);
                  return `${prefix}-${s}-${Math.floor(Math.random()*1e6)}`;
                })();
                el.setAttribute('role', 'button');
                el.setAttribute('aria-controls', controlled.id);
                const isHidden = controlled.hidden || controlled.style.display === 'none';
                el.setAttribute('aria-expanded', String(!isHidden));
              }
            });

            // ARIA + visibility
            panel.hidden = false;
            panel.style.display = '';
            panel.style.visibility = 'visible';
            panel.setAttribute('role', panel.getAttribute('role') || 'region');
            panel.setAttribute('aria-label', panel.getAttribute('aria-label') || label);
            panel.setAttribute('aria-hidden', 'false');
            if (!panel.hasAttribute('tabindex')) panel.setAttribute('tabindex', '-1');
            if (!panel.hasAttribute('aria-live')) panel.setAttribute('aria-live', 'polite');

            // Link trigger ↔ panel
            if (!panel.id) panel.id = (function genId(prefix = 'rfv-def') {
              const s = Date.now().toString(36);
              return `${prefix}-${s}-${Math.floor(Math.random()*1e6)}`;
            })();
            a.setAttribute('aria-controls', panel.id);
            a.setAttribute('aria-expanded', 'true');
            a.setAttribute('aria-describedby', panel.id);

            // Focus and remember
            if (focus) {
              try {
                if (!panel.hasAttribute('tabindex')) panel.setAttribute('tabindex', '-1');
                panel.focus({ preventScroll: false });
              } catch (_) {}
            }
            Show.lastAR = panel;
            Show.lastTrigger = a;

            // ESC-to-dismiss popup (Shadow DOM–safe, removes listener)
            const whichRoot = (rootNode && typeof rootNode.addEventListener === 'function') ? rootNode : document;

            const escHandler = (e) => {
              if (e.key !== 'Escape') return;

              // Only dismiss if ESC originated from within the same tree/panel
              const path = e.composedPath ? e.composedPath() : [];
              const insidePanel = path.includes(panel) || (panel.contains && panel.contains(path[0]));

              if (!insidePanel) return;

              // Restore focus to trigger (accessibility)
              try { Show.lastTrigger && Show.lastTrigger.focus({ preventScroll: true }); } catch {}

              // Hide/remove the popup
              if (panel && panel.parentNode) {
                panel.parentNode.removeChild(panel);
              }

              // Cleanup listener and state
              whichRoot.removeEventListener('keydown', escHandler, true);
              Show.lastAR = null;
              Show.lastTrigger = null;

              e.stopPropagation();
              e.preventDefault();
            }
            // Register the listener in the *same tree* as the popup
            whichRoot.addEventListener('keydown', escHandler, true);

            // Store it on the panel so hideAR() can detach later
            panel.__rfvEscHandler = escHandler;
          },

          /** Hide last panel and update ARIA */
          hideAR() {
            const panel = Show.lastAR;
            if (!panel) return;

            // Determine the correct active element (Shadow DOM vs Document)
            let active = null;
            const root = (panel.getRootNode && panel.getRootNode() instanceof ShadowRoot)
              ? panel.getRootNode()
              : document;

            try {
              active = root.activeElement || document.activeElement;
            } catch (_) {
              active = document.activeElement;
            }

            // If focus is inside panel, move it away
            if (active && panel.contains(active)) {
              const fallback =
                Show.lastTrigger ||
                document.getElementById('main-content') ||
                panel.parentElement;

              if (fallback && typeof fallback.focus === 'function') {
                try { fallback.focus({ preventScroll: true }); } catch (_) {}
              }
            }

            // --- Clean up the ESC listener installed in showAR() ---
            if (panel.__rfvEscHandler) {
              try {
                const trigger = Show.lastTrigger;
                let escRoot = null;

                if (trigger && trigger.getRootNode && trigger.getRootNode() instanceof ShadowRoot) {
                  escRoot = trigger.getRootNode();
                } else if (panel.getRootNode && panel.getRootNode() instanceof ShadowRoot) {
                  escRoot = panel.getRootNode();
                } else {
                  escRoot = document;
                }

                escRoot.removeEventListener('keydown', panel.__rfvEscHandler, true);
              } catch (_) {}

              delete panel.__rfvEscHandler;
            }


            // REMOVE PANEL ENTIRELY (instead of hiding it) ---
            if (panel && panel.parentNode) {
                panel.parentNode.removeChild(panel);
            }

            // Reflect collapsed state on the trigger
            if (Show.lastTrigger) {
              try {
                Show.lastTrigger.setAttribute('aria-expanded', 'false');
                Show.lastTrigger.removeAttribute('aria-describedby');
              } catch (_) {}
            }

            // Reset state
            Show.lastAR = null;
            Show.lastTrigger = null;
          },

          /**
           * Toggle the next DIV after 'a'.
           * Keeps 'aria-expanded' in sync; uses 'hidden' for visibility.
           */
          toggleNext(a, opts = {}) {
            const {
              labelExpanded = null,
              labelCollapsed = null,
              focus = false,
              selector = 'DIV' // default panel tag
            } = opts;

            const panel = findNextMatching(a, selector);
            if (!panel) return;

            normalizeTriggerAndPanel(a, panel);

            const wasHidden = panel.hidden || panel.style.display === 'none';
            // If collapsing and the panel contains focus, return focus to the trigger
            if (!wasHidden /* about to collapse */) {
              const active = document.activeElement;
              if (panel.contains(active)) {
                try { a.focus(); } catch (_) { /* ignore */ }
              }
            }
            panel.hidden = !wasHidden;
            panel.style.display = ''; // clear legacy displays
            a.setAttribute('aria-expanded', String(wasHidden));
            panel.setAttribute('aria-hidden', String(!wasHidden));

            // If expanded, remove inert; if collapsed, add inert
            try {
              if (wasHidden) panel.removeAttribute('inert');  // expanded
              else           panel.setAttribute('inert', ''); // collapsed
            } catch (_) { /* ignore */ }

            if (labelExpanded && labelCollapsed) {
              a.setAttribute('aria-label', wasHidden ? labelExpanded : labelCollapsed);
            }
            if (focus && wasHidden) safeFocus(panel);
          },
        };

        // ------- helpers ----------
        function findNextMatching(node, selector) {
          let e = node && node.nextSibling;
          while (e) {
            if (e.nodeType === Node.ELEMENT_NODE && e.matches && e.matches(selector)) return e;
            e = e.nextSibling;
          }
          return null;
        }

        // Find the next sibling element with a specific tag name (e.g., "DIV", "TABLE")
        function findNextOfType(node, tagName) {
          let e = node && node.nextSibling;
          while (e) {
            if (e.nodeType === Node.ELEMENT_NODE && e.nodeName === tagName) return e;
            e = e.nextSibling;
          }
          return null;
        }

        function insertAfter(newNode, referenceNode) {
          referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
        }
        function normalizeTriggerAndPanel(trigger, panel) {
          if (!panel.id) panel.id = generateId('rfv-panel');
          if (!panel.hasAttribute('tabindex')) panel.setAttribute('tabindex', '-1');
          panel.setAttribute('aria-hidden', String(panel.hidden));
          if (trigger.tagName !== 'BUTTON') trigger.setAttribute('role', 'button');
          trigger.setAttribute('aria-controls', panel.id);
          if (!trigger.hasAttribute('aria-expanded')) {
            const expanded = !(panel.hidden || panel.style.display === 'none');
            trigger.setAttribute('aria-expanded', String(expanded));
          }
        }
        function safeFocus(el) {
          try {
            if (!el.hasAttribute('tabindex')) el.setAttribute('tabindex', '-1');
            el.focus({ preventScroll: false });
          } catch (_) {}
        }
        let __id = 0;
        function generateId(prefix = 'rfv') {
          __id += 1;
          return `${prefix}-${Date.now().toString(36)}-${__id}`;
        }
        // Escape id for querySelector
        function cssEscape(id) {
          return (window.CSS && CSS.escape) ? CSS.escape(id) : id.replace(/([ #.;?+*~\':"!^$[\]()=>|\/@])/g, '\\$1');
        }

        // Initialize after DOM ready (menu exists in assembled HTML)
        $(function () {
          RFV.initMenu();
        });
      })(window);

      // Legacy shim so existing onclick="highlight(this)" still works
      window.highlight = function (el) { window.RFV && window.RFV.highlight(el); };

      var isRedline = (location.href.indexOf("&redline=true") >= 0 || location.href.indexOf("?redline=true") >= 0);
      function applyRedline(url) { return isRedline ? (url + "&redline=true") : url; }

      var url_filing_dir = (('') ? '' : (location.pathname.replace(/\/[^/]*$/, '/') || '/'))
            .replace(/\/$/,'');  // remove any trailing '/' for ix_viewer_url
      function ix_viewer_url(report_file) {
        // provide URL to initiate inline XBRL viewer for report_file
        return applyRedline(`/ix?doc=${url_filing_dir}/${report_file}&xbrl=true`);
      }

      // Auto-load the first report if available (SEC site behavior)
      (function () {
        var n = 1;
        if (typeof n === 'number') {
          try { window.loadReport(n, scrollToMainContent=false); } catch (e) { /* ignore */ }
        } else {
          __rfvSetReady(); // make visible anyway, to show any error messages
        }
      }());

      requestAnimationFrame(() => {
        setTimeout(() => {
          const btn = document.getElementById(`menu_r1`);
          if (btn) {
            btn.classList.add('is-selected');
            btn.setAttribute('aria-current', 'page');
          }
        }, 200); // wait until first report is drawn to highlight initial button
      });

      // --- Enhanced Keyboard Shortcuts for Pane Navigation (WCAG-compliant) ---
      (function () {
        const MENU_EL = document.getElementById('menu');
        const CONTENT_EL = document.getElementById('reportDiv');

        // Candidate elements that can be focusable
        const CANDIDATE_SEL = 'button, [role="button"], a[href], input, select, textarea, [tabindex]';

        function isFocusable(el) {
          if (!el) return false;
          // Not focusable when disabled
          if (el.hasAttribute('disabled')) return false;
          // Respect aria-hidden
          if (el.getAttribute('aria-hidden') === 'true') return false;
          // Skip tabindex="-1"
          const ti = el.getAttribute('tabindex');
          if (ti !== null && Number(ti) < 0) return false;
          // Links must have href
          if (el.tagName.toLowerCase() === 'a' && !el.hasAttribute('href')) return false;
          // Must be visible (rough check)
          const styles = window.getComputedStyle(el);
          if (styles.visibility === 'hidden' || styles.display === 'none') return false;
          // If not fixed, ensure it has layout rects
          const rects = el.getClientRects();
          if (!rects || rects.length === 0) {
            const pos = styles.position;
            if (pos !== 'fixed') return false;
          }
          return true;
        }

        // Find the first focusable descendant in a given root (Element, DocumentFragment, ShadowRoot)
        function firstFocusable(root) {
          if (!root) return null;
          try {
            const list = root.querySelectorAll(CANDIDATE_SEL);
            for (const el of list) {
              if (isFocusable(el)) return el;
            }
          } catch (_) { /* ignore */ }
          return null;
        }

        function pickMenuTarget(menu) {
          if (!menu) return null;
          // Prefer currently selected entry
          const selected = menu.querySelector('.is-selected');
          if (selected && isFocusable(selected)) return selected;
          // Else first focusable in the menu
          return firstFocusable(menu);
        }

        function pickContentTarget(pane) {
          if (!pane) return null;
          // 1) Shadow DOM first
          const sr = pane.shadowRoot || pane._shadowRoot || null;
          const shadowTarget = sr ? firstFocusable(sr) : null;
          if (shadowTarget) return shadowTarget;

          // 2) Light DOM fallback
          const lightTarget = firstFocusable(pane);
          if (lightTarget) return lightTarget;

          // 3) Region fallback (ensure pane can receive focus)
          if (!pane.hasAttribute('tabindex')) pane.setAttribute('tabindex', '-1');
          return pane;
        }

        function safeFocus(el) {
          if (!el) return;
          try { el.focus({ preventScroll: false }); } catch (_) { /* ignore */ }
        }

        function announce(msg) {
          const status = document.getElementById('rfv-status');
          if (status) status.textContent = msg || '';
        }

        document.addEventListener('keydown', function (e) {
          // Alt+M, Alt+Left → menu
          if (e.altKey && (e.key === 'm' || e.key === 'M' || e.key === 'ArrowLeft')) {
            e.preventDefault();
            safeFocus(pickMenuTarget(MENU_EL));
            
            return;
          }
          // Alt+C, Alt+Right → content (first actionable)
          if (e.altKey && (e.key === 'c' || e.key === 'C' || e.key === 'ArrowRight')) {
            e.preventDefault();
            safeFocus(pickContentTarget(CONTENT_EL));
            announce('Moved to report content');
            return;
          }
          // A simple overlay (or inline help at the top) that appears with Alt+/ (or Alt+?) to reduce user questions.
          if (e.altKey && (e.key === '/' || e.key === '?')) {
            e.preventDefault();
            alert(
              'Keyboard shortcuts:\n' +
              'Alt+M / Alt+←  → Menu (selected item or first actionable)\n' +
              'Alt+C / Alt+→  → Report content (first actionable element)\n' +
              'Tab / Shift+Tab → Normal navigation in DOM order\n' +
              'Esc → Close definition pop‑ups'
            );
            return;
          }

        });

      })();