@aceshooting/lyra-ui 3.7.0 → 3.9.0

package/dist/components/markdown/markdown-core.class.js

@@ -0,0 +1,999 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { unsafeHTML } from 'lit/directives/unsafe-html.js';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { srOnly } from '../../internal/a11y.js';
+import { prefersReducedMotion } from '../../internal/motion.js';
+import { Slugger } from '../../internal/slugger.js';
+import { DocumentAnchorTarget } from '../../internal/anchor-target.js';
+import { scopeFromElement, resolveTextQuote, buildQuoteAnchor } from '../../internal/text-quote.js';
+import { acquireHighlightHandle, supportsCustomHighlights } from '../../internal/text-highlights.js';
+import { finiteInteger } from '../../internal/numbers.js';
+import { loadMarkdownDeps, getMarkdownDepsIfLoaded } from './markdown-loader.js';
+import { loadShikiHighlighterCore, normalizeShikiLanguage, SHIKI_THEMES, } from '../code-block/code-loader.js';
+import { getKatex } from './katex-loader.js';
+import { styles } from './markdown.styles.js';
+const HTML_ESCAPES = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+function escapeHtml(text) {
+    return text.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
+}
+/**
+ * Mirrors marked's own default `link()` renderer's `cleanUrl()`: a malformed
+ * percent-escape or lone UTF-16 surrogate in the raw href throws inside
+ * `encodeURI`, and marked's default renderer responds by dropping the anchor
+ * (rendering the link text alone) rather than emitting a broken `href` —
+ * returning `null` here lets the caller do the same. The
+ * `.replace(/%25/g, '%')` compensates for `encodeURI` re-escaping the `%` of
+ * an href that was already percent-encoded (the common case for a real
+ * markdown link) — without it, every existing `%XX` escape would become
+ * `%25XX`, double-encoding it.
+ */
+function cleanHref(href) {
+    try {
+        return encodeURI(href).replace(/%25/g, '%');
+    }
+    catch {
+        return null;
+    }
+}
+/** Every `LyraHighlightTone`, used to always call `HighlightHandle.setRanges()` once per tone on
+ *  every repaint (with an empty array for an unused tone) -- `setRanges()` replaces a tone's ranges
+ *  wholesale per call, so a tone this pass has nothing for still needs an explicit empty call to
+ *  clear whatever it painted last pass. */
+const HIGHLIGHT_TONES = ['accent', 'success', 'warning', 'danger', 'neutral'];
+/** Upper bound on `highlightCache` entries per instance. Each entry holds a fully-highlighted
+ *  HTML string (potentially large for a long code block), and the cache is content-addressed --
+ *  on a long-lived instance whose `content` keeps changing (a chat transcript, live docs), an
+ *  unbounded map would retain the highlighted HTML of every code block ever rendered. 100 far
+ *  exceeds the fenced-block count of any one document, so eviction only trims blocks that
+ *  scrolled out of the content long ago. */
+const HIGHLIGHT_CACHE_MAX = 100;
+// -- math (KaTeX) -----------------------------------------------------------------------------
+/** Resolved once per page and reused by every `<lyra-markdown>` instance, mirroring
+ *  `markdown-loader.ts`'s own "warm cache" shape: `undefined` means no load has been kicked off
+ *  yet, `null` a load finished but the peer isn't installed, and it's set to `null` synchronously
+ *  the instant a load starts as an in-flight marker so a second concurrent instance never kicks off
+ *  a duplicate `getKatex()` call. */
+let resolvedKatex;
+/** Whether `getKatex()` has already been kicked off, module-wide -- kept separate from
+ *  `resolvedKatex` so "a load is in flight" and "a load finished and the peer is confirmed
+ *  missing" stay distinguishable (both would otherwise collapse to the same falsy `null`). */
+let katexLoadStarted = false;
+/** Test-only override bypassing the real dynamic `import('katex')` and the module cache above
+ *  entirely -- `undefined` (the default) defers to `resolvedKatex`. */
+let katexOverride;
+/** @internal Test-only seam: forces `math` rendering to behave as if `katex` resolved to `katex`
+ *  (or, with `null`, as if the optional peer failed to load). Pass `undefined` to restore the real
+ *  `getKatex()`-driven behavior. */
+export function __setKatexForTesting(katex) {
+    katexOverride = katex;
+}
+function getKatexIfLoaded() {
+    return katexOverride !== undefined ? katexOverride : (resolvedKatex ?? null);
+}
+/** Whether the `katex` load has definitively finished with no peer available -- distinct from
+ *  `getKatexIfLoaded()` returning falsy, which also covers a load that's merely still in flight
+ *  (the state a math token's render-time literal fallback uses regardless of which case it is).
+ *  Used only to decide whether a literal fallback should also report `lyra-render-error`. */
+function isKatexConfirmedMissing() {
+    return (katexOverride !== undefined ? katexOverride : resolvedKatex) === null;
+}
+const MATH_BLOCK_RE = /^\$\$([^\n]+?)\$\$/;
+const MATH_INLINE_RE = /^\$((?:\\\$|[^$\s])(?:\\\$|[^$])*?)\$(?!\$)/;
+/** A marked inline-level extension recognizing `$...$` and `$$...$$` TeX. Tokenizing is
+ *  synchronous (matching marked's own parse pass); actual KaTeX rendering happens in `renderMath`
+ *  against whatever `getKatexIfLoaded()` already has resolved -- mirroring this component's
+ *  existing two-phase pattern for fenced-code highlighting (`code()` returns a plain placeholder
+ *  first; the real highlighted markup arrives one render later once shiki resolves). `renderer` is
+ *  bundled directly into this same extension object (not marked's separate top-level `.use({
+ *  renderer })` override hook -- that hook only recognizes the *built-in* renderer method names;
+ *  a custom token type introduced via `.use({ extensions })` supplies its own renderer the same way). */
+function mathExtension(renderMath) {
+    return {
+        name: 'math',
+        level: 'inline',
+        start(src) {
+            const index = src.indexOf('$');
+            return index === -1 ? undefined : index;
+        },
+        tokenizer(src) {
+            const block = MATH_BLOCK_RE.exec(src);
+            if (block)
+                return { type: 'math', raw: block[0], tex: block[1].trim(), display: true };
+            const inline = MATH_INLINE_RE.exec(src);
+            if (inline)
+                return { type: 'math', raw: inline[0], tex: inline[1].replace(/\\\$/g, '$').trim(), display: false };
+            return undefined;
+        },
+        renderer(token) {
+            return renderMath(token);
+        },
+    };
+}
+/**
+ * Rewrites shiki's generated `<pre>`/`<code>` hast nodes so the highlighted output keeps
+ * `<lyra-markdown>`'s own `part="code-block"` hook and a `language-${lang}` class on `<code>` --
+ * matching today's plain-render output shape exactly, so existing consumer CSS targeting either
+ * keeps working whether or not a given block ended up highlighted. A separate, purpose-built
+ * function from `code-block.class.ts`'s own (private, non-exported) `partTransformer` -- that one
+ * targets `<lyra-code-block>`'s own `part="pre"`/`part="code"`/line-numbers contract, which doesn't
+ * apply here.
+ */
+function markdownCodeTransformer(lang) {
+    return {
+        name: 'lyra-markdown-code-block',
+        pre(node) {
+            node.properties.part = ['code-block'];
+            delete node.properties.tabindex;
+        },
+        code(node) {
+            const classes = Array.isArray(node.properties.class)
+                ? node.properties.class
+                : node.properties.class
+                    ? [node.properties.class]
+                    : [];
+            node.properties.class = [...classes, `language-${lang}`];
+        },
+    };
+}
+class LyraMarkdownCoreBase extends LyraElement {
+}
+/**
+ * `<lyra-markdown-core>` — a build-lean variant of `<lyra-markdown>` for a consumer whose
+ * `languages` map already covers every language it will ever render. Every other capability (GFM
+ * tables, fenced code blocks, links, blockquotes, heading anchors, text-quote highlights, math) is
+ * identical to `<lyra-markdown>` -- only fenced-code-block highlighting differs: this component's
+ * own module never textually contains a call to (or import of) `loadShikiHighlighter` (the
+ * ~200-language default dynamic-import table `<lyra-markdown>` calls unconditionally unless its
+ * *runtime* `languagesOnly` flag is `true` -- a flag on that same module a bundler can't prove
+ * always-true, so the unconditional call stays in the build output regardless). A consumer
+ * importing this entry point instead of `markdown.js` gets a genuinely shiki-full-table-free
+ * build. A fenced block whose language isn't a key in `languages` always renders the plain-text
+ * fallback -- there is no default/full-table highlighter here to fall back to, mirroring
+ * `<lyra-code-block-core>`'s identical contract for the sibling component.
+ *
+ * Built on the optional peer dependencies `marked` (parsing) and `dompurify` (sanitizing), both
+ * lazy-loaded via `markdown-loader.ts` on first connect.
+ *
+ * Rendering never ships unsanitized or broken markup silently:
+ * - If `marked` fails to load, or throws while parsing malformed input, the
+ *   component falls back to plain text (`white-space: pre-wrap`, no HTML
+ *   parsing at all) and fires `lyra-render-error`.
+ * - If `sanitize` is `true` (the default) and `dompurify` fails to load, the
+ *   component *also* falls back to plain text + `lyra-render-error` — it
+ *   never renders marked's raw HTML output when sanitization was requested
+ *   (or defaulted to) but is unavailable, even though `marked` itself loaded
+ *   fine.
+ * - If `sanitize` is explicitly `false`, marked's raw output renders as-is
+ *   regardless of whether `dompurify` is installed — the consumer opted out
+ *   of sanitization, so `dompurify`'s absence is irrelevant to that path.
+ *
+ * That same plain-text fallback rendering (`data-fallback` on the `content`
+ * part) is also, unconditionally and by default, a brief *transient* state on
+ * every connect, not just a failure path: `connectedCallback()`'s dynamic
+ * `import()` of `marked`/`dompurify` (see `markdown-loader.ts`) is
+ * asynchronous, so the very first paint of any `<lyra-markdown>` on a page
+ * shows plain text for at least one microtask — even when both peers are
+ * already installed and load without error — until that import resolves and
+ * a second render replaces it with the real Markdown output. Set
+ * `eager-load` to skip that window once the shared dependency cache is
+ * already warm; see that property's doc for exactly what "warm" requires.
+ *
+ * `heading`/`code`/`blockquote`/`table`/`link`/`image` tokens are rendered
+ * through a `marked` renderer override that injects `part="..."` attributes
+ * directly into the produced HTML — a single pass, not a second DOM walk
+ * after insertion.
+ *
+ * Fenced code blocks are syntax-highlighted via the same fine-grained `shiki/core` recipe
+ * `<lyra-code-block-core>` uses (`highlightCode`, default `true` — gated by whether a fenced
+ * block's language is a key in `languages`, since there is no default highlighter here to gate on
+ * "is shiki installed at all"). The very first render of any content is always plain (identical to
+ * `<lyra-markdown>`'s own output); highlighting arrives as an asynchronous upgrade one render
+ * later, once the fine-grained highlighter resolves. No highlighting is attempted while
+ * `streaming` is `true` — it applies once a stream settles, so there is no added per-chunk cost
+ * while content is still arriving.
+ *
+ * When `heading-anchors` is set, every rendered heading's slug (computed via the shared
+ * GitHub-slugger-style `Slugger`) is stamped as its `id`; `getHeadingTree()` computes that same
+ * outline on every parse regardless of `heading-anchors`, so a host can build a table of contents
+ * even while ids aren't in the DOM yet. `scrollToAnchor()` (from the adopted `DocumentAnchorTarget`
+ * mixin) resolves `fragment` anchors against that outline and `text-quote` anchors via
+ * `internal/text-quote.ts`'s shared scope/resolve helpers; `highlights` re-resolve by quote after
+ * every render (never by node identity), so a highlight painted before a `streaming` update
+ * finishes still finds its quote once the matching text arrives. Highlight painting uses
+ * `internal/text-highlights.ts`'s `acquireHighlightHandle()` -- the CSS Custom Highlight API where
+ * the browser supports it (no DOM mutation at all), a `<mark>`-wrap fallback otherwise.
+ *
+ * `math` renders `$...$`/`$$...$$` TeX as MathML via the optional `katex` peer's
+ * `renderToString(tex, { output: 'mathml' })` -- MathML Core renders natively and accessibly in
+ * evergreen browsers with no extra stylesheet or webfont needing to cross the shadow boundary. A
+ * missing `katex` peer renders the literal, unparsed TeX source (delimiters included) and fires one
+ * `lyra-render-error`.
+ *
+ * @customElement lyra-markdown-core
+ * @event lyra-link-click - Fired (and the click prevented) when a rendered
+ *   link's `href` starts with `internal-link-prefix`. `detail: { href:
+ *   string, internal: true }`. Ordinary external links navigate normally
+ *   (in `link-target`) and never fire this event.
+ * @event lyra-render-error - Fired whenever rendering falls back to plain
+ *   text, or `math` is set but the `katex` peer isn't installed. `detail: { error: unknown }`.
+ * @event lyra-highlight-activate - A painted `text-quote` highlight was clicked. `detail: { id }`.
+ * @event lyra-text-select - Fired on selection end inside the rendered content. `detail: { text,
+ *   anchor, rects }`; `anchor` is a `text-quote` `LyraAnchor` scoped to the rendered content, or
+ *   `null` if the selection couldn't be anchored.
+ * @event lyra-anchor-result - Fired after an `anchor` property assignment or a `scrollToAnchor()`
+ *   call is applied. `detail: { found }`.
+ * @csspart content - The wrapper around the rendered (or plain-text
+ *   fallback) output.
+ * @csspart heading - Every rendered `<h1>`–`<h6>` (shifted by
+ *   `heading-offset`).
+ * @csspart paragraph - Every rendered `<p>`.
+ * @csspart list - Every rendered `<ul>`/`<ol>`.
+ * @csspart code-block - Every rendered fenced/indented `<pre>`.
+ * @csspart inline-code - Every rendered inline `<code>` span (backtick spans, not fenced blocks).
+ * @csspart link - Every rendered `<a>`.
+ * @csspart table - Every rendered `<table>`.
+ * @csspart blockquote - Every rendered `<blockquote>`.
+ * @csspart img - Every rendered `<img>`.
+ * @csspart math - A rendered inline or block math span (`data-display="inline"|"block"`).
+ */
+export class LyraMarkdownCore extends DocumentAnchorTarget(LyraMarkdownCoreBase) {
+    constructor() {
+        super(...arguments);
+        /** The Markdown source to render. */
+        this.content = '';
+        /** Sanitize marked's HTML output with DOMPurify before rendering. See the
+         *  class doc for what happens when this is `true` (the default) but the
+         *  `dompurify` peer isn't installed. */
+        this.sanitize = true;
+        /** When `true`, overrides marked's `html` renderer hook to emit the HTML-escaped source text
+         *  instead of passing raw/sanitized markup through -- for a consumer rendering arbitrary
+         *  already-written content (e.g. a historical chat/agent transcript full of code/XML/HTML
+         *  snippets) where a stray angle bracket should render as visible text, not a real DOM element.
+         *  Still lets GFM tables/lists/etc. render normally -- only raw embedded HTML is affected.
+         *  `false` (the default) reproduces today's exact `marked`-default (sanitized-when-`sanitize`)
+         *  passthrough behavior. */
+        this.escapeHtml = false;
+        /** Enable GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists). */
+        this.gfm = true;
+        /** `target` applied to every rendered `<a>`, with `rel="noopener
+         *  noreferrer"` always added alongside it whenever a `target` is emitted.
+         *  `'_blank'` (the default) preserves today's exact output. Set to `null`
+         *  (or the empty string, e.g. via the `link-target=""` attribute) to omit
+         *  `target`/`rel` entirely, so rendered links open in the same tab. */
+        this.linkTarget = '_blank';
+        /** When set, a rendered link whose `href` starts with this prefix is
+         *  treated as internal — its click is intercepted and reported via
+         *  `lyra-link-click` instead of navigating. Empty (the default) means
+         *  every link is treated as external. */
+        this.internalLinkPrefix = '';
+        /** Added to every rendered heading's source `token.depth` before emitting
+         *  `<h${depth}>` — e.g. `heading-offset="2"` renders a source `#` as
+         *  `<h3>` and a source `##` as `<h4>`. The result is clamped to `[1, 6]`
+         *  (a source `######` with a positive offset stays at `<h6>` rather than
+         *  overflowing past the HTML heading levels; the floor at `1` is
+         *  defensive, since this property is meant to be additive-only). `0`
+         *  (the default) preserves today's exact `<h${token.depth}>` output. */
+        this.headingOffset = 0;
+        /** When `true`, `connectedCallback()` skips awaiting `loadMarkdownDeps()`'s
+         *  dynamic `import()` if the shared `marked`/`dompurify` module cache (see
+         *  `markdown-loader.ts`'s `getMarkdownDepsIfLoaded()`) has *already*
+         *  resolved — e.g. because an earlier `<lyra-markdown>` instance on the
+         *  page already finished loading, or the consumer primed the cache
+         *  directly by calling `loadMarkdownDeps()` themselves at startup — and
+         *  renders synchronously instead. When the cache isn't warm yet (most
+         *  notably: the very first `<lyra-markdown>` ever connected on a page,
+         *  since nothing has called `loadMarkdownDeps()` before it), this still
+         *  falls back to the normal async path — a dynamic `import()` can't be
+         *  made synchronous, so this is a fast path for the common "already warm"
+         *  case, not a hard guarantee. `false` (the default) is byte-identical to
+         *  today: always the async `import()`, fallback-text window included. */
+        this.eagerLoad = false;
+        /** Signals that `content` is still arriving incrementally. Content changes
+         *  continue to render immediately; while this is `true`, the host remains
+         *  `aria-busy="true"` so assistive technology knows the rendered document
+         *  is not final. Set it back to `false` with the final content update.
+         *  Reflects so a consumer can also target `lyra-markdown[streaming]`. */
+        this.streaming = false;
+        /** Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lyra-code-block>`
+         *  uses. `true` (the default) upgrades every fenced block from plain `<pre><code>` once the peer
+         *  is available -- a pure upgrade, not a behavior change gated on opt-in, since it's itself gated
+         *  transparently by whether `shiki` is installed at all (an app that never installs it sees
+         *  byte-identical output to today). Set `false` to keep plain output even when `shiki` is
+         *  installed. No effect while `streaming` is `true` -- see that property's own doc. */
+        this.highlightCode = true;
+        /** Grammar definitions this instance can highlight, e.g. `{ json: jsonGrammar }` (import from
+         *  `shiki/langs/<name>.mjs`), forwarded verbatim to `loadShikiHighlighterCore()` -- same shape as
+         *  `<lyra-code-block-core>`'s own `languages`. This component has no default/full-table
+         *  highlighter to fall back to -- a fenced block whose language isn't a key here always renders
+         *  the plain-text fallback. Empty (the default) never highlights anything. */
+        this.languages = {};
+        /** Stamps a computed slug as `id` on every rendered heading. `getHeadingTree()` computes the
+         *  same slugs regardless of this property -- it only controls whether the `id` attribute is
+         *  emitted into the rendered DOM. `false` (the default) preserves today's exact output.
+         *
+         *  When `sanitize` is also on (the default), a slug whose *value* collides with a real
+         *  `document` property name (e.g. a heading literally titled "Title", "Location", or "Forms"
+         *  slugs to `title`/`location`/`forms`) has its `id` silently stripped by DOMPurify's DOM-
+         *  clobbering protection (`SANITIZE_DOM`) -- `getHeadingTree()` still reports that heading's slug
+         *  either way, but `scrollToAnchor({ kind: 'fragment', id })` still resolves it correctly even
+         *  without a DOM `id` present, via its own position-based fallback lookup. */
+        this.headingAnchors = false;
+        /** Renders `$...$`/`$$...$$` TeX via the optional `katex` peer, as MathML. `false` (the
+         *  default) renders `$...$` literally, unparsed -- today's exact output. */
+        this.math = false;
+        /** Anchor kinds this component resolves via `scrollToAnchor()`. Readonly. */
+        this.anchorKinds = ['fragment', 'text-quote'];
+        // `null` covers both "the optional peers are still loading" and "a render
+        // attempt just fell back after a failure" — the two states intentionally
+        // look identical (plain text, see render()) since a consumer distinguishes
+        // them via `lyra-render-error`, not a visual difference.
+        this.renderedHtml = null;
+        /** Document-ordered heading outline computed on every parse (see `getHeadingTree()`), regardless
+         *  of `headingAnchors`. */
+        this.headingTree = [];
+        /** The most recently resolved `text-quote` highlight ranges, kept for `onContentClick()`'s
+         *  coordinate hit-test -- the CSS Custom Highlight API paints ranges without creating any DOM
+         *  element to attach a click listener to, so activation is resolved by comparing the click point
+         *  against each range's own `getClientRects()` instead, uniformly across both paint paths. */
+        this.resolvedHighlightRanges = [];
+        /** Guards `lyra-render-error` so a permanently-missing `katex` peer reports once per instance,
+         *  not on every subsequent re-render while `math` stays on. Reset whenever `math` toggles. */
+        this.mathFailureReported = false;
+        /** `(lang, code)` -> already-highlighted HTML, content-addressed (see `PendingHighlight`'s doc).
+         *  Persists across renders of this instance; populated asynchronously by `highlightPending()`.
+         *  Never consulted while `streaming` is `true` or `highlightCode` is `false` -- both gates live
+         *  in the `code()` renderer inside `parseMarkdown()`. Bounded to {@link HIGHLIGHT_CACHE_MAX}
+         *  entries, least-recently-used first out, via `getCachedHighlight()`/`setCachedHighlight()` --
+         *  always go through those instead of the map directly so hits refresh recency. */
+        this.highlightCache = new Map();
+        /** Bumped on every `highlightPending()` call, including ones that end up not actually loading
+         *  anything -- guards against a newer `content`/`streaming` change superseding an older in-flight
+         *  highlight, exactly mirroring `<lyra-code-block>`'s own `highlightToken` field for the identical
+         *  race (an async grammar load resolving after a newer call already produced correct output). */
+        this.highlightToken = 0;
+        /** Keys from `PendingHighlight` that failed to highlight -- peer missing, language unrecognized,
+         *  or tokenization threw. Once a key lands here, `code()` stops re-discovering it as pending on
+         *  every future render. Without this, a permanently-unhighlightable block (e.g. an unrecognized
+         *  language) would never get cached, so every `renderMarkdown()` pass -- including the one
+         *  `highlightPending()` itself triggers on completion -- would rediscover it as pending and retry
+         *  it again, forever. Mirrors `code-loader.ts`'s own `unsupportedLanguages` Set, which exists for
+         *  the identical reason one level down (a single unrecognized `language` value on
+         *  `<lyra-code-block>`). */
+        this.failedHighlightKeys = new Set();
+        // A single delegated listener on the content wrapper (not one per <a>) —
+        // the rendered markup is fully replaced on every content change, so a
+        // per-anchor listener would need re-attaching on every render anyway.
+        this.onContentClick = (e) => {
+            const highlightId = this.hitTestHighlightAt(e.clientX, e.clientY);
+            if (highlightId) {
+                this.emit('lyra-highlight-activate', { id: highlightId });
+                return;
+            }
+            const prefix = this.internalLinkPrefix;
+            if (!prefix)
+                return;
+            const anchor = e.composedPath().find((el) => el instanceof HTMLAnchorElement);
+            if (!anchor)
+                return;
+            // Compared against the raw `href` *attribute*, not the `.href` IDL
+            // property — the property is always browser-resolved to an absolute URL
+            // (e.g. "https://example.com/docs") even for a relative/prefixed path,
+            // which would never match a relative `internal-link-prefix`.
+            const href = anchor.getAttribute('href') ?? '';
+            if (!href.startsWith(prefix))
+                return;
+            e.preventDefault();
+            this.emit('lyra-link-click', { href, internal: true });
+        };
+    }
+    static { this.styles = [LyraElement.styles, styles, srOnly]; }
+    /** LRU read: a hit is re-inserted so Map iteration order (insertion order) keeps the first key
+     *  the least recently used one -- the entry `setCachedHighlight()` evicts when full. */
+    getCachedHighlight(key) {
+        const cached = this.highlightCache.get(key);
+        if (cached !== undefined) {
+            this.highlightCache.delete(key);
+            this.highlightCache.set(key, cached);
+        }
+        return cached;
+    }
+    setCachedHighlight(key, html) {
+        if (this.highlightCache.has(key)) {
+            this.highlightCache.delete(key);
+        }
+        else if (this.highlightCache.size >= HIGHLIGHT_CACHE_MAX) {
+            const oldest = this.highlightCache.keys().next().value;
+            if (oldest !== undefined)
+                this.highlightCache.delete(oldest);
+        }
+        this.highlightCache.set(key, html);
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        if (this.eagerLoad) {
+            // Only takes this synchronous path when the shared module cache has
+            // *already* settled (see getMarkdownDepsIfLoaded()'s doc) -- otherwise
+            // falls through to the same async path as the default below, since a
+            // dynamic import() can't be made synchronous from scratch.
+            const alreadyLoaded = getMarkdownDepsIfLoaded();
+            if (alreadyLoaded) {
+                this.deps = alreadyLoaded;
+                this.renderMarkdown();
+                return;
+            }
+        }
+        void loadMarkdownDeps().then((resolved) => {
+            // The (module-cached, page-lifetime) loadMarkdownDeps() promise can
+            // resolve after this instance was removed from the DOM -- e.g. an
+            // <lyra-markdown> inside a conditionally-rendered chat message or a
+            // virtualized list. Without this guard, a detached instance would
+            // still have its `deps` set and renderMarkdown() called, mutating the
+            // @state() renderedHtml property and scheduling a Lit update no one
+            // will ever see. Mirrors chart.ts's own connectedCallback() guard for
+            // the identical race.
+            if (!this.isConnected)
+                return;
+            this.deps = resolved;
+            this.renderMarkdown();
+        });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback(); // reaches DocumentAnchorTarget's own cleanup (anchor retry, selection binding)
+        this.highlightHandle?.release();
+        this.highlightHandle = undefined;
+    }
+    /** Binds selection -> `lyra-text-select` once, on the stable `[part="content"]` wrapper --
+     *  re-renders only replace that wrapper's children via `unsafeHTML`, never the wrapper itself.
+     *  `bindTextSelection` is `protected` on the mixin's own narrowed return type (deliberately not
+     *  part of `LyraAnchorTarget`'s public surface -- see `anchor-target.ts`'s class doc), so it's
+     *  reached the same way that module's own tests do: through a cast, without declaring a no-op
+     *  passthrough override just to satisfy the type checker. */
+    firstUpdated() {
+        const contentRoot = this.renderRoot.querySelector('[part="content"]');
+        if (!contentRoot)
+            return;
+        this.bindTextSelection(contentRoot);
+    }
+    // Runs before render (not updated()) so mutating the `renderedHtml` state
+    // property below is absorbed into the *same* update cycle instead of
+    // scheduling a second one -- Lit's documented pattern for deriving one
+    // reactive property from a change to others.
+    willUpdate(changed) {
+        super.willUpdate(changed); // reaches DocumentAnchorTarget's own willUpdate (declarative `anchor`)
+        if (changed.has('math'))
+            this.mathFailureReported = false;
+        if (!this.deps) {
+            // Still loading the optional peers — the connectedCallback promise
+            // above calls renderMarkdown() itself once they resolve, using
+            // whatever property values are current at that time.
+            return;
+        }
+        if (changed.has('content') ||
+            changed.has('sanitize') ||
+            changed.has('gfm') ||
+            changed.has('linkTarget') ||
+            changed.has('headingOffset') ||
+            changed.has('escapeHtml') ||
+            changed.has('streaming') ||
+            changed.has('headingAnchors') ||
+            changed.has('math')) {
+            this.renderMarkdown();
+        }
+    }
+    updated(changed) {
+        super.updated(changed);
+        if (this.deps && !this.streaming) {
+            this.removeAttribute('aria-busy');
+        }
+        else {
+            this.setAttribute('aria-busy', 'true');
+        }
+        if (changed.has('renderedHtml') || changed.has('highlights') || changed.has('activeHighlightId')) {
+            this.repaintHighlights();
+        }
+    }
+    renderMarkdown() {
+        const deps = this.deps;
+        if (!deps)
+            return;
+        if (!deps.marked) {
+            // markdown-loader.ts already logged the specific import failure.
+            this.applyFallback(new Error('<lyra-markdown> could not render: the "marked" peer dependency failed to load.'));
+            return;
+        }
+        const pendingKeys = [];
+        const headingTree = [];
+        let rawHtml;
+        let hadMathFallback;
+        try {
+            const parsed = this.parseMarkdown(deps.marked, pendingKeys, headingTree);
+            rawHtml = parsed.html;
+            hadMathFallback = parsed.hadMathFallback;
+        }
+        catch (error) {
+            this.applyFallback(error);
+            return;
+        }
+        this.headingTree = headingTree;
+        this.maybeLoadKatex();
+        // A math token rendering its literal fallback only means the `katex` peer is *confirmed*
+        // missing once loading has actually settled -- otherwise this is just the same one-microtask
+        // "still loading" window every other optional peer here has, and reporting it as an error
+        // would be a false positive.
+        const mathFailed = hadMathFallback && isKatexConfirmedMissing();
+        if (!this.sanitize) {
+            // Consumer explicitly opted out of sanitization — dompurify's
+            // presence or absence is irrelevant to this path.
+            this.renderedHtml = rawHtml;
+            if (mathFailed)
+                this.reportMathFailure();
+            this.maybeHighlightPending(pendingKeys);
+            return;
+        }
+        if (!deps.DOMPurify) {
+            const error = new Error('<lyra-markdown> could not render: sanitize is enabled (the default) but the "dompurify" peer ' +
+                'dependency failed to load — refusing to render unsanitized HTML. Install it with `pnpm add ' +
+                'dompurify`, or set sanitize="false" to explicitly opt out of sanitization.');
+            console.warn(error.message);
+            this.applyFallback(error);
+            return;
+        }
+        // `target` is not in DOMPurify's default attribute allowlist (unlike
+        // `part`/`rel`/`class`, which already are) — without ADD_ATTR here,
+        // every rendered link's target="..." would be silently stripped even
+        // though the anchor itself survives sanitization.
+        // 'style' joins 'target' in the added-attribute allowlist -- shiki's per-token output carries
+        // inline style="color:..." (theme colors), which isn't in DOMPurify's default attribute
+        // allowlist any more than 'target' was.
+        // `semantics`/`annotation` join the allowlist only when `math` is on -- the only KaTeX MathML
+        // output elements outside DOMPurify's default allowlist. `annotation-xml` is deliberately never
+        // added -- KaTeX's own MathML output never emits it, and DOMPurify's default allowlist already
+        // treats it as a namespace-switching element worth keeping stripped.
+        this.renderedHtml = deps.DOMPurify.sanitize(rawHtml, {
+            ADD_ATTR: ['target', 'style'],
+            ...(this.math ? { ADD_TAGS: ['semantics', 'annotation'] } : {}),
+        });
+        if (mathFailed)
+            this.reportMathFailure();
+        this.maybeHighlightPending(pendingKeys);
+    }
+    applyFallback(error) {
+        this.renderedHtml = null;
+        this.emit('lyra-render-error', { error });
+    }
+    /** Kicks off the shared `katex` load the first time `math` needs it and no attempt is already
+     *  in flight (module-scoped, so every `<lyra-markdown>` instance on the page shares one load --
+     *  mirrors `markdown-loader.ts`'s own warm-cache shape). Skipped entirely under
+     *  `__setKatexForTesting()` -- that seam controls math-rendering behavior directly and must never
+     *  race a real, unmocked `import('katex')` settling underneath it. */
+    maybeLoadKatex() {
+        if (!this.math || katexLoadStarted || katexOverride !== undefined)
+            return;
+        katexLoadStarted = true;
+        void getKatex().then((katex) => {
+            resolvedKatex = katex;
+            if (!this.isConnected)
+                return;
+            this.renderMarkdown();
+        });
+    }
+    /** Fires `lyra-render-error` once per instance for a permanently-missing `katex` peer. Called
+     *  only once `renderMarkdown()` has confirmed the peer is actually missing (`katexOverride` or
+     *  the resolved module is `null`) -- a math token rendering its literal fallback while the load
+     *  is merely still in flight (the same one-microtask transient window every other optional peer
+     *  in this component has) never reports an error on its own. */
+    reportMathFailure() {
+        if (this.mathFailureReported)
+            return;
+        this.mathFailureReported = true;
+        this.emit('lyra-render-error', {
+            error: new Error('<lyra-markdown> needs the optional peer dependency `katex` to render math (the `math` property is set) — install it with `pnpm add katex`.'),
+        });
+    }
+    /** Kicks off async highlighting for `pendingKeys` (see `highlightPending()`) unless there's
+     *  nothing to do, `highlightCode` is off, or `streaming` is on -- called from both of
+     *  `renderMarkdown()`'s exit points (the `sanitize=false` early return and the normal sanitized
+     *  path), since highlighting is independent of that decision. */
+    maybeHighlightPending(pendingKeys) {
+        if (pendingKeys.length === 0 || !this.highlightCode || this.streaming)
+            return;
+        void this.highlightPending(pendingKeys);
+    }
+    /** Loads whatever shiki grammars `pendingKeys` need, tokenizes each pending block concurrently,
+     *  populates `highlightCache` with the results, then triggers one more `renderMarkdown()` pass so
+     *  the newly-cached entries actually reach the screen. A pending key whose language isn't a key in
+     *  `languages`, or otherwise fails to tokenize, is recorded in `failedHighlightKeys` -- it stays
+     *  uncached, so `code()` keeps emitting its plain fallback for it on every future render, and
+     *  `code()` also stops re-discovering it as pending (see `failedHighlightKeys`'s own doc for why
+     *  that matters: without it, the `renderMarkdown()` call at the end of this method would
+     *  rediscover the same permanently-uncacheable key as pending on every pass, forever). Does not
+     *  block or delay any other pending key -- each is tried independently via `Promise.all`. */
+    async highlightPending(pendingKeys) {
+        const token = ++this.highlightToken;
+        const languages = this.languages;
+        const tokenizeOne = async (pending) => {
+            const normalizedLang = normalizeShikiLanguage(pending.lang);
+            if (!languages[normalizedLang] && !languages[pending.lang]) {
+                // Not in the supplied languages map -- there is no default/full-table highlighter to fall
+                // back to in this variant (mirrors <lyra-code-block-core>). Permanent for this key:
+                // failedHighlightKeys is never cleared, and languages isn't in willUpdate()'s trigger list,
+                // so changing it doesn't retry this key on its own.
+                this.failedHighlightKeys.add(pending.key);
+                return;
+            }
+            const hl = await loadShikiHighlighterCore(languages);
+            if (!hl) {
+                this.failedHighlightKeys.add(pending.key);
+                return;
+            }
+            try {
+                const html = hl.codeToHtml(pending.code, {
+                    lang: normalizedLang,
+                    themes: SHIKI_THEMES,
+                    transformers: [markdownCodeTransformer(pending.lang)],
+                });
+                this.setCachedHighlight(pending.key, `${html}\n`);
+            }
+            catch {
+                this.failedHighlightKeys.add(pending.key);
+                // Tokenization failed for a reason other than an unrecognized grammar -- leave this key
+                // uncached, same effect as an unrecognized language: permanent plain fallback for this
+                // specific block.
+            }
+        };
+        await Promise.all(pendingKeys.map(tokenizeOne));
+        if (token !== this.highlightToken || !this.isConnected)
+            return;
+        this.renderMarkdown();
+    }
+    parseMarkdown(marked, pendingKeys, headingTreeOut) {
+        // Falsy (`null` or `''`) means the consumer explicitly opted out of
+        // target="..."/rel="..." on rendered links -- see the linkTarget doc.
+        // The default '_blank' is already truthy, so this preserves today's
+        // exact output when the property is left unset.
+        const linkTarget = this.linkTarget;
+        // A raw NaN (e.g. an invalid `heading-offset` attribute) would otherwise flow straight into
+        // `token.depth + headingOffset` below, producing a NaN heading depth and an invalid `<hNaN>`
+        // tag -- finiteInteger() normalizes it back to the documented `0` (additive-only) default.
+        const headingOffset = finiteInteger(this.headingOffset, 0);
+        // Captured as a local distinct from the free function `escapeHtml` above
+        // (imported/defined at the top of this file) to avoid shadowing/
+        // ambiguity inside the renderer closure below, matching how
+        // `linkTarget`/`headingOffset` are already captured as locals for the
+        // same reason.
+        const escapeHtmlOption = this.escapeHtml;
+        const highlightCodeOption = this.highlightCode && !this.streaming;
+        // Bound method reference (not the raw map): reads must go through the LRU accessor so a hit
+        // refreshes its recency. The renderer methods below run with marked's own `this`.
+        const getCachedHighlight = (key) => this.getCachedHighlight(key);
+        const failedHighlightKeys = this.failedHighlightKeys;
+        const headingAnchorsOption = this.headingAnchors;
+        const slugger = new Slugger();
+        const mathOption = this.math;
+        const cachedKatex = mathOption ? getKatexIfLoaded() : null;
+        let hadMathFallback = false;
+        const instance = new marked.Marked();
+        if (mathOption) {
+            instance.use({
+                extensions: [
+                    mathExtension((token) => {
+                        if (!cachedKatex) {
+                            hadMathFallback = true;
+                            return escapeHtml(token.display ? `$$${token.tex}$$` : `$${token.tex}$`);
+                        }
+                        try {
+                            const mathml = cachedKatex.renderToString(token.tex, { output: 'mathml', throwOnError: false });
+                            return `<span part="math" data-display="${token.display ? 'block' : 'inline'}">${mathml}</span>`;
+                        }
+                        catch {
+                            // throwOnError: false already handles a malformed-TeX render internally (KaTeX's own
+                            // inline error form); this catch only guards against an unexpected non-KaTeX failure,
+                            // e.g. a broken/incompatible peer version -- same literal fallback, no event fired.
+                            return escapeHtml(token.display ? `$$${token.tex}$$` : `$${token.tex}$`);
+                        }
+                    }),
+                ],
+            });
+        }
+        // A fresh renderer per parse (rather than a shared/cached one) so it
+        // always closes over the *current* `linkTarget`/`headingOffset` — these
+        // properties can change between renders, and marked's `.use()` otherwise
+        // persists whatever renderer it was given for the lifetime of the
+        // instance.
+        instance.use({
+            renderer: {
+                heading(token) {
+                    // Clamped to [1, 6]: a positive offset can never push a heading
+                    // past <h6> (there is no <h7>), and the floor at 1 is defensive
+                    // since headingOffset is meant to be additive-only (0 is the only
+                    // documented non-positive value).
+                    const depth = Math.min(6, Math.max(1, token.depth + headingOffset));
+                    // Rendered through the plain textRenderer so markup never leaks into the slug -- an
+                    // inline <code>/<em> inside a heading collapses to plain text for slugging purposes.
+                    const label = this.parser.parseInline(token.tokens, this.parser.textRenderer);
+                    const slug = slugger.slug(label);
+                    headingTreeOut.push({ id: slug, label, level: depth });
+                    const idAttr = headingAnchorsOption && slug ? ` id="${escapeHtml(slug)}"` : '';
+                    return `<h${depth} part="heading"${idAttr}>${this.parser.parseInline(token.tokens)}</h${depth}>\n`;
+                },
+                paragraph(token) {
+                    return `<p part="paragraph">${this.parser.parseInline(token.tokens)}</p>\n`;
+                },
+                list(token) {
+                    const ordered = token.ordered;
+                    const start = token.start;
+                    let body = '';
+                    for (const item of token.items)
+                        body += this.listitem(item);
+                    const tag = ordered ? 'ol' : 'ul';
+                    const startAttr = ordered && start !== 1 ? ` start="${start}"` : '';
+                    return `<${tag} part="list"${startAttr}>\n${body}</${tag}>\n`;
+                },
+                code(token) {
+                    const lang = (token.lang ?? '').trim().split(/\s+/)[0] ?? '';
+                    const body = `${token.text.replace(/\n$/, '')}\n`;
+                    const text = token.escaped ? body : escapeHtml(body);
+                    if (highlightCodeOption && lang) {
+                        const key = `${lang}\n${body}`;
+                        const cached = getCachedHighlight(key);
+                        if (cached !== undefined)
+                            return cached;
+                        if (!failedHighlightKeys.has(key))
+                            pendingKeys.push({ key, lang, code: body });
+                    }
+                    const cls = lang ? ` class="language-${escapeHtml(lang)}"` : '';
+                    return `<pre part="code-block"><code${cls}>${text}</code></pre>\n`;
+                },
+                codespan(token) {
+                    // Mirrors marked's own default codespan() renderer's escaping exactly (it does not
+                    // pre-escape token.text itself) -- only the added part="inline-code" differs.
+                    return `<code part="inline-code">${escapeHtml(token.text)}</code>`;
+                },
+                blockquote(token) {
+                    return `<blockquote part="blockquote">\n${this.parser.parse(token.tokens)}</blockquote>\n`;
+                },
+                table(token) {
+                    // Built directly here (rather than delegating to the inherited
+                    // tablecell()) so a scope="col" can be added -- marked's own
+                    // default tablecell() never emits it, and without it a screen
+                    // reader can't reliably associate a data cell with its column
+                    // header beyond the simplest table.
+                    let headerRow = '';
+                    for (const cell of token.header) {
+                        const text = this.parser.parseInline(cell.tokens);
+                        const alignAttr = cell.align ? ` align="${cell.align}"` : '';
+                        headerRow += `<th scope="col"${alignAttr}>${text}</th>`;
+                    }
+                    let bodyRows = '';
+                    for (const row of token.rows) {
+                        let rowHtml = '';
+                        for (const cell of row)
+                            rowHtml += this.tablecell(cell);
+                        bodyRows += this.tablerow({ text: rowHtml });
+                    }
+                    const thead = `<thead>\n${this.tablerow({ text: headerRow })}</thead>\n`;
+                    const tbody = bodyRows ? `<tbody>${bodyRows}</tbody>\n` : '';
+                    return `<table part="table">\n${thead}${tbody}</table>\n`;
+                },
+                link(token) {
+                    const text = this.parser.parseInline(token.tokens);
+                    const href = cleanHref(token.href);
+                    if (href === null)
+                        return text;
+                    const titleAttr = token.title ? ` title="${escapeHtml(token.title)}"` : '';
+                    const targetAttr = linkTarget
+                        ? ` target="${escapeHtml(linkTarget)}" rel="noopener noreferrer"`
+                        : '';
+                    return `<a part="link" href="${escapeHtml(href)}"${titleAttr}${targetAttr}>${text}</a>`;
+                },
+                image(token) {
+                    // Mirrors marked's own default image() renderer (alt text
+                    // re-rendered through the plain textRenderer so nested emphasis/
+                    // strong/etc. inside the alt collapses to plain text, href run
+                    // through the same cleanHref() the link() override above uses)
+                    // with a part="img" added.
+                    const altText = this.parser.parseInline(token.tokens, this.parser.textRenderer);
+                    const href = cleanHref(token.href);
+                    if (href === null)
+                        return escapeHtml(altText);
+                    const titleAttr = token.title ? ` title="${escapeHtml(token.title)}"` : '';
+                    return `<img part="img" src="${escapeHtml(href)}" alt="${escapeHtml(altText)}"${titleAttr}>`;
+                },
+                html(token) {
+                    return escapeHtmlOption ? escapeHtml(token.text) : token.text;
+                },
+            },
+        });
+        return { html: instance.parse(this.content, { gfm: this.gfm, async: false }), hadMathFallback };
+    }
+    /** A document-ordered, flattened heading outline -- computed on every parse regardless of
+     *  `headingAnchors` (see that property's own doc). A caller building a table of contents can rely
+     *  on this even while `heading-anchors` is off. */
+    getHeadingTree() {
+        return [...this.headingTree];
+    }
+    contentRoot() {
+        return this.renderRoot.querySelector('[part="content"]');
+    }
+    // -- anchor-target: applyAnchor per kind -----------------------------------------------------
+    async applyAnchor(anchor) {
+        const root = this.contentRoot();
+        if (!root)
+            return false;
+        switch (anchor.kind) {
+            case 'fragment':
+                return this.applyFragmentAnchor(root, anchor);
+            case 'text-quote':
+                return this.applyTextQuoteAnchor(root, anchor);
+            default:
+                return false;
+        }
+    }
+    applyFragmentAnchor(root, anchor) {
+        if (!anchor.id)
+            return false;
+        const known = this.headingTree.some((h) => h.id === anchor.id);
+        if (!known)
+            return false;
+        const el = root.querySelector(`#${CSS.escape(anchor.id)}`) ?? this.findHeadingByComputedId(root, anchor.id);
+        if (!el)
+            return false;
+        el.scrollIntoView({ behavior: prefersReducedMotion() ? 'auto' : 'smooth', block: 'start' });
+        return true;
+    }
+    /** `headingAnchors` may be off, so a target heading might carry no `id` attribute in the DOM --
+     *  re-derives the same slug order `getHeadingTree()` was built in and matches by position
+     *  instead of by attribute. */
+    findHeadingByComputedId(root, id) {
+        const index = this.headingTree.findIndex((h) => h.id === id);
+        if (index < 0)
+            return null;
+        const headings = root.querySelectorAll('h1, h2, h3, h4, h5, h6');
+        return headings[index] ?? null;
+    }
+    applyTextQuoteAnchor(root, anchor) {
+        const range = resolveTextQuote(scopeFromElement(root), anchor);
+        if (!range)
+            return false;
+        const target = range.startContainer.nodeType === Node.ELEMENT_NODE ? range.startContainer : range.startContainer.parentElement;
+        (target ?? root).scrollIntoView({ behavior: prefersReducedMotion() ? 'auto' : 'smooth', block: 'center' });
+        return true;
+    }
+    /** Overrides `DocumentAnchorTarget`'s default (whole render-root) selection scope, matching
+     *  `heading`'s slug computation and `applyTextQuoteAnchor()` above: only `[part="content"]` is a
+     *  meaningful text-quote scope, so a selection that somehow reaches outside it (there is no other
+     *  text in this component's shadow tree today, but the live region could grow one) never leaks
+     *  into a captured anchor. */
+    computeSelectionAnchor(range) {
+        const root = this.contentRoot();
+        if (!root)
+            return null;
+        return buildQuoteAnchor(range, scopeFromElement(root));
+    }
+    // -- highlight painting ------------------------------------------------------------------------
+    ensureHighlightHandle() {
+        if (!this.highlightHandle)
+            this.highlightHandle = acquireHighlightHandle(this, this.ownerDocument);
+        return this.highlightHandle;
+    }
+    /** Re-resolves every `text-quote` highlight against the current rendered content and repaints
+     *  via `acquireHighlightHandle()` -- resolution is always by quote text, never by node identity,
+     *  so a highlight set before its quote exists in `content` yet (e.g. mid-`streaming`) simply
+     *  paints nothing until a later render's text actually contains it. `fragment` highlights aren't
+     *  painted (there is no literal span of text to wrap/underline for a whole section). */
+    repaintHighlights() {
+        this.resolvedHighlightRanges = [];
+        const root = this.contentRoot();
+        if (!root)
+            return;
+        const handle = this.ensureHighlightHandle();
+        const scope = scopeFromElement(root);
+        const rangesByTone = new Map(HIGHLIGHT_TONES.map((tone) => [tone, []]));
+        let activeRange = null;
+        for (const highlight of this.highlights) {
+            if (highlight.anchor.kind !== 'text-quote')
+                continue;
+            const range = resolveTextQuote(scope, highlight.anchor);
+            if (!range)
+                continue;
+            rangesByTone.get(highlight.tone ?? 'accent').push(range);
+            this.resolvedHighlightRanges.push({ id: highlight.id, range });
+            if (highlight.id === this.activeHighlightId)
+                activeRange = range;
+        }
+        for (const [tone, ranges] of rangesByTone)
+            handle.setRanges(tone, ranges);
+        handle.setActive(activeRange);
+        if (!supportsCustomHighlights()) {
+            // The `<mark>`-wrap fallback creates real elements but carries no `part` of its own (the
+            // module is shared by every adopting viewer, so it can't know this component's part naming)
+            // -- stamped here so a consumer can still target `::part(highlight)` in browsers lacking the
+            // CSS Custom Highlight API. Nothing to stamp on the API path: no DOM element is created there.
+            for (const mark of root.querySelectorAll('mark[data-lyra-highlight-tone]')) {
+                if (!mark.hasAttribute('part'))
+                    mark.setAttribute('part', 'highlight');
+            }
+        }
+    }
+    /** Hit-tests a click point against every currently-resolved highlight's `getClientRects()`,
+     *  topmost (last-resolved) first. The CSS Custom Highlight API paints ranges without creating any
+     *  DOM element to attach a click listener to, so this is the only activation path that works
+     *  identically on both paint paths -- mirrors `<lyra-pdf-viewer>`'s own coordinate-based
+     *  `onPageClick()` hit-test for the same reason (its own painted highlights sit under a text
+     *  layer that intercepts most pointer events). */
+    hitTestHighlightAt(x, y) {
+        for (let i = this.resolvedHighlightRanges.length - 1; i >= 0; i--) {
+            const { id, range } = this.resolvedHighlightRanges[i];
+            for (const rect of range.getClientRects()) {
+                if (x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom)
+                    return id;
+            }
+        }
+        return null;
+    }
+    render() {
+        const isFallback = this.renderedHtml === null;
+        return html `
+      <div part="content" ?data-fallback=${isFallback} @click=${this.onContentClick}>
+        ${isFallback ? this.content : unsafeHTML(this.renderedHtml)}
+      </div>
+      ${this.renderAnchorLiveRegion()}
+    `;
+    }
+}
+__decorate([
+    property()
+], LyraMarkdownCore.prototype, "content", void 0);
+__decorate([
+    property({ type: Boolean })
+], LyraMarkdownCore.prototype, "sanitize", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'escape-html' })
+], LyraMarkdownCore.prototype, "escapeHtml", void 0);
+__decorate([
+    property({ type: Boolean })
+], LyraMarkdownCore.prototype, "gfm", void 0);
+__decorate([
+    property({ attribute: 'link-target' })
+], LyraMarkdownCore.prototype, "linkTarget", void 0);
+__decorate([
+    property({ attribute: 'internal-link-prefix' })
+], LyraMarkdownCore.prototype, "internalLinkPrefix", void 0);
+__decorate([
+    property({ type: Number, attribute: 'heading-offset' })
+], LyraMarkdownCore.prototype, "headingOffset", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'eager-load' })
+], LyraMarkdownCore.prototype, "eagerLoad", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraMarkdownCore.prototype, "streaming", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'highlight-code' })
+], LyraMarkdownCore.prototype, "highlightCode", void 0);
+__decorate([
+    property({ attribute: false })
+], LyraMarkdownCore.prototype, "languages", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'heading-anchors' })
+], LyraMarkdownCore.prototype, "headingAnchors", void 0);
+__decorate([
+    property({ type: Boolean })
+], LyraMarkdownCore.prototype, "math", void 0);
+__decorate([
+    state()
+], LyraMarkdownCore.prototype, "renderedHtml", void 0);
+//# sourceMappingURL=markdown-core.class.js.map