@aceshooting/lyra-ui 7.3.0 → 7.4.0

package/dist/components/conversation/markdown/markdown-shared.d.ts

@@ -1,15 +1,28 @@
 /**
- * Shared parsing/cache logic for `<lr-markdown>` and `<lr-markdown-core>`. Both components render
- * an otherwise-identical document (GFM tables, fenced code blocks, links, blockquotes, headings,
- * math) and previously duplicated their entire `parseMarkdown()` implementation (and the small
- * `highlightCache` LRU helpers around it) verbatim across both class files -- mirroring the same
- * drift risk `code-block-shared.ts` was created to end for the `<lr-code-block>` /
- * `<lr-code-block-core>` pair. A fix or behavior change to Markdown parsing now has exactly one
- * place to land. `highlightPending()` (the shiki-loading strategy) is deliberately *not* here --
- * it's the one piece that genuinely differs between the full and lean-bundle variants.
+ * Everything `<lr-markdown>` and `<lr-markdown-core>` parse, render and compute identically: the
+ * whole `marked` renderer contract (`parseMarkdownDocument()`), the `highlightCache` LRU helpers
+ * around it, the optional-peer load/sanitize/fallback pipeline (`renderMarkdownDocument()`), the
+ * `katex` resolution state, `fragment`/`text-quote` anchor application, highlight painting and
+ * hit-testing, the internal-link contract, and the rendered `[part="content"]` template itself.
+ *
+ * The two components differ in exactly one axis -- *which* shiki loader highlights a fenced block
+ * (the full ~200-language dynamic-import table plus a per-language `loadLanguage()`, vs.
+ * `shiki/core` seeded from a pre-supplied `languages` map), which is why `highlightPending()` stays
+ * on each class. Everything else was previously duplicated verbatim across both ~890-line class
+ * files, mirroring the same drift risk `code-block-shared.ts` was created to end for the
+ * `<lr-code-block>` / `<lr-code-block-core>` pair. A fix or behavior change now has exactly one
+ * place to land.
+ *
+ * Nothing here may `import` a *value* from `code-loader.js`'s full-table half
+ * (`loadShikiHighlighter`/`loadShikiLanguage`): `<lr-markdown-core>`'s build-leanness claim rests on
+ * its own module graph never reaching that call, and this module is in that graph.
  */
+import { type TemplateResult } from 'lit';
 import type { OptionalPeerApi } from '../../../internal/optional-peer-types.js';
-import type { KatexApi } from './katex-loader.js';
+import { type HighlightHandle } from '../../../internal/text-highlights.js';
+import type { LyraAnchor, LyraHighlight } from '../../viewers/document-viewer/anchors.js';
+import { type MarkdownDeps } from './markdown-loader.js';
+import { type KatexApi } from './katex-loader.js';
 export declare function escapeHtml(text: string): string;
 /**
  * Mirrors marked's own default `link()` renderer's `cleanUrl()`: a malformed
@@ -90,4 +103,195 @@ export declare function parseMarkdownDocument(options: ParseMarkdownOptions): {
     html: string;
     hadMathFallback: boolean;
 };
+/**
+ * One variant's `katex` bookkeeping. Deliberately *per-variant* rather than one process-wide
+ * singleton: each of `<lr-markdown>`/`<lr-markdown-core>` creates exactly one of these at its own
+ * module scope, reproducing the four module-level bindings each class file used to declare for
+ * itself. Sharing a single instance across both would also share `loadStarted`, so a
+ * `<lr-markdown>` that started the load would suppress a `<lr-markdown-core>`'s own
+ * re-render-on-resolve on the same page (and vice versa) -- a behavior change this extraction has
+ * no reason to make. The underlying `getKatex()` promise is page-cached anyway, so two states cost
+ * one load.
+ */
+export interface MarkdownKatexState {
+    /** Test-only override bypassing the real dynamic `import('katex')` and the module cache
+     *  entirely -- `undefined` (the default) defers to the resolved module. */
+    setForTesting(katex: KatexApi | null | undefined): void;
+    /** The katex module to render this pass's math with, or `null` for the literal-TeX fallback
+     *  (peer missing *or* still loading -- the fallback is the same either way). */
+    getIfLoaded(): KatexApi | null;
+    /** Whether the load has definitively finished with no peer available -- distinct from
+     *  `getIfLoaded()` returning falsy, which also covers a load that's merely still in flight. Used
+     *  only to decide whether a literal fallback should also report `lr-render-error`. */
+    isConfirmedMissing(): boolean;
+    /** Kicks off the shared page-wide `getKatex()` load the first time math needs it, at most once.
+     *  Skipped entirely while `setForTesting()` is active -- that seam controls math-rendering
+     *  behavior directly and must never race a real, unmocked `import('katex')` settling underneath
+     *  it. `onResolved` runs after the module lands; the caller still guards its own liveness. */
+    startLoad(onResolved: () => void): void;
+}
+export declare function createMarkdownKatexState(): MarkdownKatexState;
+/**
+ * Rewrites shiki's generated `<pre>`/`<code>` hast nodes so the highlighted output keeps the
+ * markdown viewers' own `part="code-block"` hook and a `language-${lang}` class on `<code>` --
+ * matching the 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-shared.ts`'s own `codeBlockLineTransformer` -- that one targets
+ * `<lr-code-block>`'s `part="pre"`/`part="code"`/line-numbers contract, which doesn't apply here.
+ */
+export declare function markdownCodeTransformer(lang: string): {
+    name: string;
+    pre(node: OptionalPeerApi): void;
+    code(node: OptionalPeerApi): void;
+};
+/**
+ * Tokenizes one pending fenced block with an already-resolved highlighter and returns the exact
+ * string to cache (trailing newline included, matching the plain `code()` renderer's own output).
+ * `null` means "leave this key uncached" -- the caller records it in `failedHighlightKeys` so the
+ * block keeps its plain fallback permanently rather than being rediscovered as pending forever.
+ * Shared by both variants' `highlightPending()`; only the *loading* half above it differs.
+ */
+export declare function tokenizeMarkdownHighlight(hl: OptionalPeerApi, pending: PendingHighlight): string | null;
+/**
+ * `connectedCallback()`'s optional-peer load for both variants. `eagerLoad` only takes the
+ * synchronous path when the shared `marked`/`dompurify` module cache has *already* settled (see
+ * `getMarkdownDepsIfLoaded()`'s doc) -- otherwise it falls through to the same async path as the
+ * default, since a dynamic `import()` can't be made synchronous from scratch.
+ *
+ * The (module-cached, page-lifetime) `loadMarkdownDeps()` promise can resolve after the instance
+ * was removed from the DOM -- e.g. a markdown viewer inside a conditionally-rendered chat message
+ * or a virtualized list. Without the `isConnected` guard, a detached instance would still have its
+ * deps applied and a render scheduled that no one will ever see. Mirrors `chart.ts`'s own
+ * `connectedCallback()` guard for the identical race.
+ */
+export declare function beginMarkdownDepsLoad(host: {
+    readonly eagerLoad: boolean;
+    readonly isConnected: boolean;
+}, apply: (deps: MarkdownDeps) => void): void;
+/** Every property whose change means the document has to be reparsed. `languagesOnly` is listed
+ *  for `<lr-markdown>`; `<lr-markdown-core>` has no such property, so it simply never appears in
+ *  that component's changed map. */
+export declare function markdownNeedsReparse(changed: Map<PropertyKey, unknown>): boolean;
+/** Whether the *highlighting* configuration changed, invalidating in-flight work and the
+ *  permanently-failed key set. */
+export declare function markdownHighlightConfigChanged(changed: Map<PropertyKey, unknown>): boolean;
+/** Whether the *grammar set* changed, additionally invalidating already-highlighted output. */
+export declare function markdownLanguageSetChanged(changed: Map<PropertyKey, unknown>): boolean;
+/** The rendered outcome of one `renderMarkdownDocument()` pass. `headingTree` is non-`null`
+ *  whenever the parse itself succeeded -- including the `fallback` produced by a missing
+ *  `dompurify`, which still computed a real outline before refusing to render. */
+export type MarkdownRenderOutcome = {
+    status: 'fallback';
+    error: unknown;
+    headingTree: MarkdownHeadingItem[] | null;
+} | {
+    status: 'rendered';
+    html: string;
+    headingTree: MarkdownHeadingItem[];
+    /** A math token rendered its literal TeX fallback *and* the peer is confirmed missing --
+     *  worth one `lr-render-error`. A fallback while the load is merely still in flight is the
+     *  same one-microtask transient window every other optional peer here has, and reporting it
+     *  would be a false positive. */
+    mathFailed: boolean;
+    pendingKeys: PendingHighlight[];
+};
+export interface RenderMarkdownOptions {
+    /** This variant's own tag, for the peer-failure diagnostics below. */
+    tag: 'lr-markdown' | 'lr-markdown-core';
+    deps: MarkdownDeps;
+    sanitize: boolean;
+    math: boolean;
+    /** The instance's own `parseMarkdown()` -- see `ParseMarkdownOptions` for what it resolves. */
+    parse: (marked: OptionalPeerApi, pendingKeys: PendingHighlight[], headingTreeOut: MarkdownHeadingItem[]) => {
+        html: string;
+        hadMathFallback: boolean;
+    };
+    /** Runs immediately after a successful parse, before sanitization -- where each instance kicks
+     *  off its variant's katex load. */
+    onParsed: () => void;
+    isKatexConfirmedMissing: () => boolean;
+}
+/**
+ * The optional-peer load / parse / sanitize / fallback pipeline both variants run, returning what
+ * changed rather than mutating the instance -- the caller owns every `@state` assignment and every
+ * event, so this stays a pure function of its inputs.
+ *
+ * Rendering never ships unsanitized or broken markup silently: a missing/throwing `marked`, or a
+ * missing `dompurify` while `sanitize` is on, both fall back to plain text plus `lr-render-error`;
+ * an explicit `sanitize="false"` renders marked's raw output regardless of whether `dompurify` is
+ * installed, because the consumer opted out.
+ */
+export declare function renderMarkdownDocument(options: RenderMarkdownOptions): MarkdownRenderOutcome;
+/** The `lr-render-error` payload for a permanently-missing `katex` peer while `math` is set. */
+export declare function markdownMathPeerError(tag: 'lr-markdown' | 'lr-markdown-core'): Error;
+/** Mirrors "the document is not final" onto the host as `aria-busy`, so assistive technology knows
+ *  the rendered output is still resolving (peers loading, or `streaming` still on). */
+export declare function applyMarkdownAriaBusy(host: Element, busy: boolean): void;
+/**
+ * Scrolls a `fragment` anchor's heading into view. `headingAnchors` may be off, so the target
+ * heading might carry no `id` attribute in the DOM at all -- and even with it on, DOMPurify's
+ * DOM-clobbering protection strips a slug colliding with a real `document` property name. Both
+ * cases fall back to re-deriving the same slug order `getHeadingTree()` was built in and matching
+ * by position instead of by attribute.
+ */
+export declare function applyMarkdownFragmentAnchor(root: Element, anchor: Extract<LyraAnchor, {
+    kind: 'fragment';
+}>, headingTree: readonly MarkdownHeadingItem[]): boolean;
+/** Scrolls a `text-quote` anchor's resolved range into view, centered. */
+export declare function applyMarkdownTextQuoteAnchor(root: Element, anchor: Extract<LyraAnchor, {
+    kind: 'text-quote';
+}>): boolean;
+/** One `text-quote` highlight resolved against the currently rendered content. */
+export interface ResolvedHighlightRange {
+    id: string;
+    range: Range;
+}
+/**
+ * Re-resolves every `text-quote` highlight against the current rendered content and repaints via
+ * the caller's `acquireHighlightHandle()` handle -- 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).
+ * Returns the resolved ranges for `hitTestHighlightRanges()` to activate against.
+ */
+export declare function repaintMarkdownHighlights(options: {
+    root: Element;
+    handle: HighlightHandle;
+    highlights: readonly LyraHighlight[];
+    activeHighlightId: string | null;
+}): ResolvedHighlightRange[];
+/**
+ * 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 `<lr-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).
+ */
+export declare function hitTestHighlightRanges(ranges: readonly ResolvedHighlightRange[], x: number, y: number): string | null;
+/** The `href` of the rendered link a click landed on, when `internal-link-prefix` claims it --
+ *  `null` for every other click, including one on an ordinary external link.
+ *
+ *  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`. */
+export declare function internalLinkHrefFrom(e: MouseEvent, prefix: string): string | null;
+export interface MarkdownContentOptions {
+    /** The Markdown source -- also the plain-text fallback rendering when `renderedHtml` is `null`. */
+    content: string;
+    /** Sanitized (or deliberately unsanitized) HTML, or `null` for the plain-text fallback: peers
+     *  still loading, or a render attempt just fell back after a failure. The two states look
+     *  identical on purpose -- a consumer distinguishes them via `lr-render-error`. */
+    renderedHtml: string | null;
+    /** The host's own `aria-label`, forwarded to the element that actually owns `role="document"` --
+     *  a host `aria-label` doesn't reach shadow internals on its own. */
+    hostAriaLabel: string | null;
+    onClick: (e: MouseEvent) => void;
+    /** `DocumentAnchorTarget`'s `renderAnchorLiveRegion()` output. */
+    liveRegion: unknown;
+}
+/** The rendered tree both variants produce: one `[part="content"]` wrapper plus the anchor-target
+ *  live region. Only non-empty content is focusable -- an empty document is not a scrollable region
+ *  worth a tab stop. */
+export declare function renderMarkdownContent(options: MarkdownContentOptions): TemplateResult;
 //# sourceMappingURL=markdown-shared.d.ts.map

package/dist/components/conversation/markdown/markdown-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown-shared.d.ts","sourceRoot":"","sources":["../../../../src/components/conversation/markdown/markdown-shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAGhF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAUlD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMrD;AAED;;;gGAGgG;AAChG,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;sGACsG;AACtG,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;4CAK4C;AAC5C,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;wFACwF;AACxF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO9F;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,GAAG,GAAE,MAA4B,GAChC,IAAI,CAQN;AA4CD;;;YAGY;AACZ,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,OAAO,CAAC;IACb,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;iDAC6C;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,OAAO,CAAC;IAC1B;2EACuE;IACvE,mBAAmB,EAAE,OAAO,CAAC;IAC7B;iDAC6C;IAC7C,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACxD,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB;;6EAEyE;IACzE,WAAW,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,cAAc,EAAE,mBAAmB,EAAE,CAAC;CACvC;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,CAoJ/G"}
+{"version":3,"file":"markdown-shared.d.ts","sourceRoot":"","sources":["../../../../src/components/conversation/markdown/markdown-shared.ts"],"names":[],"mappings":"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"}

package/dist/components/conversation/markdown/markdown-shared.js

@@ -1,15 +1,32 @@
 /**
- * Shared parsing/cache logic for `<lr-markdown>` and `<lr-markdown-core>`. Both components render
- * an otherwise-identical document (GFM tables, fenced code blocks, links, blockquotes, headings,
- * math) and previously duplicated their entire `parseMarkdown()` implementation (and the small
- * `highlightCache` LRU helpers around it) verbatim across both class files -- mirroring the same
- * drift risk `code-block-shared.ts` was created to end for the `<lr-code-block>` /
- * `<lr-code-block-core>` pair. A fix or behavior change to Markdown parsing now has exactly one
- * place to land. `highlightPending()` (the shiki-loading strategy) is deliberately *not* here --
- * it's the one piece that genuinely differs between the full and lean-bundle variants.
+ * Everything `<lr-markdown>` and `<lr-markdown-core>` parse, render and compute identically: the
+ * whole `marked` renderer contract (`parseMarkdownDocument()`), the `highlightCache` LRU helpers
+ * around it, the optional-peer load/sanitize/fallback pipeline (`renderMarkdownDocument()`), the
+ * `katex` resolution state, `fragment`/`text-quote` anchor application, highlight painting and
+ * hit-testing, the internal-link contract, and the rendered `[part="content"]` template itself.
+ *
+ * The two components differ in exactly one axis -- *which* shiki loader highlights a fenced block
+ * (the full ~200-language dynamic-import table plus a per-language `loadLanguage()`, vs.
+ * `shiki/core` seeded from a pre-supplied `languages` map), which is why `highlightPending()` stays
+ * on each class. Everything else was previously duplicated verbatim across both ~890-line class
+ * files, mirroring the same drift risk `code-block-shared.ts` was created to end for the
+ * `<lr-code-block>` / `<lr-code-block-core>` pair. A fix or behavior change now has exactly one
+ * place to land.
+ *
+ * Nothing here may `import` a *value* from `code-loader.js`'s full-table half
+ * (`loadShikiHighlighter`/`loadShikiLanguage`): `<lr-markdown-core>`'s build-leanness claim rests on
+ * its own module graph never reaching that call, and this module is in that graph.
  */
+import { html, nothing } from 'lit';
+import { unsafeHTML } from 'lit/directives/unsafe-html.js';
 import { Slugger } from '../../../internal/slugger.js';
 import { finiteInteger } from '../../../internal/numbers.js';
+import { prefersReducedMotion } from '../../../internal/motion.js';
+import { scopeFromElement, resolveTextQuote } from '../../../internal/text-quote.js';
+import { supportsCustomHighlights } from '../../../internal/text-highlights.js';
+import { normalizeShikiLanguage, SHIKI_THEMES } from '../code-block/code-loader.js';
+import { loadMarkdownDeps, getMarkdownDepsIfLoaded } from './markdown-loader.js';
+import { getKatex } from './katex-loader.js';
 const HTML_ESCAPES = {
     '&': '&amp;',
     '<': '&lt;',
@@ -250,4 +267,341 @@ export function parseMarkdownDocument(options) {
     });
     return { html: instance.parse(content, { gfm, async: false }), hadMathFallback };
 }
+export function createMarkdownKatexState() {
+    // `undefined` means no load has been kicked off yet, `null` that one finished but the peer isn't
+    // installed -- kept distinguishable from `loadStarted` so "in flight" and "confirmed missing"
+    // never collapse into the same falsy value.
+    let resolved;
+    let loadStarted = false;
+    let override;
+    return {
+        setForTesting(katex) {
+            override = katex;
+        },
+        getIfLoaded() {
+            return override !== undefined ? override : (resolved ?? null);
+        },
+        isConfirmedMissing() {
+            return (override !== undefined ? override : resolved) === null;
+        },
+        startLoad(onResolved) {
+            if (loadStarted || override !== undefined)
+                return;
+            loadStarted = true;
+            void getKatex().then((katex) => {
+                resolved = katex;
+                onResolved();
+            });
+        },
+    };
+}
+// -- fenced-code highlighting -------------------------------------------------------------------
+/**
+ * Rewrites shiki's generated `<pre>`/`<code>` hast nodes so the highlighted output keeps the
+ * markdown viewers' own `part="code-block"` hook and a `language-${lang}` class on `<code>` --
+ * matching the 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-shared.ts`'s own `codeBlockLineTransformer` -- that one targets
+ * `<lr-code-block>`'s `part="pre"`/`part="code"`/line-numbers contract, which doesn't apply here.
+ */
+export function markdownCodeTransformer(lang) {
+    return {
+        name: 'lr-markdown-code-block',
+        pre(node) {
+            node.properties.part = ['code-block'];
+            node.properties.tabindex = '0';
+        },
+        code(node) {
+            const classes = Array.isArray(node.properties.class)
+                ? node.properties.class
+                : node.properties.class
+                    ? [node.properties.class]
+                    : [];
+            node.properties.class = [...classes, `language-${lang}`];
+        },
+    };
+}
+/**
+ * Tokenizes one pending fenced block with an already-resolved highlighter and returns the exact
+ * string to cache (trailing newline included, matching the plain `code()` renderer's own output).
+ * `null` means "leave this key uncached" -- the caller records it in `failedHighlightKeys` so the
+ * block keeps its plain fallback permanently rather than being rediscovered as pending forever.
+ * Shared by both variants' `highlightPending()`; only the *loading* half above it differs.
+ */
+export function tokenizeMarkdownHighlight(hl, pending) {
+    try {
+        const highlighted = hl.codeToHtml(pending.code, {
+            lang: normalizeShikiLanguage(pending.lang),
+            themes: SHIKI_THEMES,
+            transformers: [markdownCodeTransformer(pending.lang)],
+        });
+        return `${highlighted}\n`;
+    }
+    catch {
+        // Tokenization failed for a reason other than an unrecognized grammar (each variant's loader
+        // reports that itself) -- same effect either way: permanent plain fallback for this block.
+        return null;
+    }
+}
+// -- the render pipeline ------------------------------------------------------------------------
+/**
+ * `connectedCallback()`'s optional-peer load for both variants. `eagerLoad` only takes the
+ * synchronous path when the shared `marked`/`dompurify` module cache has *already* settled (see
+ * `getMarkdownDepsIfLoaded()`'s doc) -- otherwise it falls through to the same async path as the
+ * default, since a dynamic `import()` can't be made synchronous from scratch.
+ *
+ * The (module-cached, page-lifetime) `loadMarkdownDeps()` promise can resolve after the instance
+ * was removed from the DOM -- e.g. a markdown viewer inside a conditionally-rendered chat message
+ * or a virtualized list. Without the `isConnected` guard, a detached instance would still have its
+ * deps applied and a render scheduled that no one will ever see. Mirrors `chart.ts`'s own
+ * `connectedCallback()` guard for the identical race.
+ */
+export function beginMarkdownDepsLoad(host, apply) {
+    if (host.eagerLoad) {
+        const alreadyLoaded = getMarkdownDepsIfLoaded();
+        if (alreadyLoaded) {
+            apply(alreadyLoaded);
+            return;
+        }
+    }
+    void loadMarkdownDeps().then((resolved) => {
+        if (!host.isConnected)
+            return;
+        apply(resolved);
+    });
+}
+/** Every property whose change means the document has to be reparsed. `languagesOnly` is listed
+ *  for `<lr-markdown>`; `<lr-markdown-core>` has no such property, so it simply never appears in
+ *  that component's changed map. */
+export function markdownNeedsReparse(changed) {
+    return (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') ||
+        changed.has('highlightCode') ||
+        changed.has('languages') ||
+        changed.has('languagesOnly'));
+}
+/** Whether the *highlighting* configuration changed, invalidating in-flight work and the
+ *  permanently-failed key set. */
+export function markdownHighlightConfigChanged(changed) {
+    return changed.has('highlightCode') || changed.has('languages') || changed.has('languagesOnly');
+}
+/** Whether the *grammar set* changed, additionally invalidating already-highlighted output. */
+export function markdownLanguageSetChanged(changed) {
+    return changed.has('languages') || changed.has('languagesOnly');
+}
+/**
+ * The optional-peer load / parse / sanitize / fallback pipeline both variants run, returning what
+ * changed rather than mutating the instance -- the caller owns every `@state` assignment and every
+ * event, so this stays a pure function of its inputs.
+ *
+ * Rendering never ships unsanitized or broken markup silently: a missing/throwing `marked`, or a
+ * missing `dompurify` while `sanitize` is on, both fall back to plain text plus `lr-render-error`;
+ * an explicit `sanitize="false"` renders marked's raw output regardless of whether `dompurify` is
+ * installed, because the consumer opted out.
+ */
+export function renderMarkdownDocument(options) {
+    const { deps, tag } = options;
+    if (!deps.marked) {
+        // markdown-loader.ts already logged the specific import failure.
+        return {
+            status: 'fallback',
+            error: new Error(`<${tag}> could not render: the "marked" peer dependency failed to load.`),
+            headingTree: null,
+        };
+    }
+    const pendingKeys = [];
+    const headingTree = [];
+    let rawHtml;
+    let hadMathFallback;
+    try {
+        const parsed = options.parse(deps.marked, pendingKeys, headingTree);
+        rawHtml = parsed.html;
+        hadMathFallback = parsed.hadMathFallback;
+    }
+    catch (error) {
+        return { status: 'fallback', error, headingTree: null };
+    }
+    options.onParsed();
+    const mathFailed = hadMathFallback && options.isKatexConfirmedMissing();
+    if (!options.sanitize) {
+        // Consumer explicitly opted out of sanitization -- dompurify's presence or absence is
+        // irrelevant to this path.
+        return { status: 'rendered', html: rawHtml, headingTree, mathFailed, pendingKeys };
+    }
+    if (!deps.DOMPurify) {
+        const error = new Error(`<${tag}> 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);
+        return { status: 'fallback', error, headingTree };
+    }
+    // `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 it because shiki's
+    // per-token output carries inline style="color:..." (theme colors), equally absent from the
+    // default allowlist. `semantics`/`annotation` join only when `math` is on -- the only KaTeX
+    // MathML output elements outside the 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.
+    const sanitized = deps.DOMPurify.sanitize(rawHtml, {
+        ADD_ATTR: ['target', 'style'],
+        ...(options.math ? { ADD_TAGS: ['semantics', 'annotation'] } : {}),
+    });
+    return { status: 'rendered', html: sanitized, headingTree, mathFailed, pendingKeys };
+}
+/** The `lr-render-error` payload for a permanently-missing `katex` peer while `math` is set. */
+export function markdownMathPeerError(tag) {
+    return new Error(`<${tag}> needs the optional peer dependency \`katex\` to render math (the \`math\` property is set) — install it with \`pnpm add katex\`.`);
+}
+/** Mirrors "the document is not final" onto the host as `aria-busy`, so assistive technology knows
+ *  the rendered output is still resolving (peers loading, or `streaming` still on). */
+export function applyMarkdownAriaBusy(host, busy) {
+    if (busy)
+        host.setAttribute('aria-busy', 'true');
+    else
+        host.removeAttribute('aria-busy');
+}
+// -- anchors ------------------------------------------------------------------------------------
+/**
+ * Scrolls a `fragment` anchor's heading into view. `headingAnchors` may be off, so the target
+ * heading might carry no `id` attribute in the DOM at all -- and even with it on, DOMPurify's
+ * DOM-clobbering protection strips a slug colliding with a real `document` property name. Both
+ * cases fall back to re-deriving the same slug order `getHeadingTree()` was built in and matching
+ * by position instead of by attribute.
+ */
+export function applyMarkdownFragmentAnchor(root, anchor, headingTree) {
+    if (!anchor.id)
+        return false;
+    const index = headingTree.findIndex((h) => h.id === anchor.id);
+    if (index < 0)
+        return false;
+    const el = root.querySelector(`#${CSS.escape(anchor.id)}`) ?? root.querySelectorAll('h1, h2, h3, h4, h5, h6')[index];
+    if (!el)
+        return false;
+    el.scrollIntoView({ behavior: prefersReducedMotion() ? 'auto' : 'smooth', block: 'start' });
+    return true;
+}
+/** Scrolls a `text-quote` anchor's resolved range into view, centered. */
+export function applyMarkdownTextQuoteAnchor(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;
+}
+// -- highlight painting ---------------------------------------------------------------------------
+/** 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'];
+/**
+ * Re-resolves every `text-quote` highlight against the current rendered content and repaints via
+ * the caller's `acquireHighlightHandle()` handle -- 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).
+ * Returns the resolved ranges for `hitTestHighlightRanges()` to activate against.
+ */
+export function repaintMarkdownHighlights(options) {
+    const resolved = [];
+    const scope = scopeFromElement(options.root);
+    const rangesByTone = new Map(HIGHLIGHT_TONES.map((tone) => [tone, []]));
+    let activeRange = null;
+    for (const highlight of options.highlights) {
+        if (highlight.anchor.kind !== 'text-quote')
+            continue;
+        const range = resolveTextQuote(scope, highlight.anchor);
+        if (!range)
+            continue;
+        rangesByTone.get(highlight.tone ?? 'accent').push(range);
+        resolved.push({ id: highlight.id, range });
+        if (highlight.id === options.activeHighlightId)
+            activeRange = range;
+    }
+    for (const [tone, ranges] of rangesByTone)
+        options.handle.setRanges(tone, ranges);
+    options.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 options.root.querySelectorAll('mark[data-lr-highlight-tone]')) {
+            if (!mark.hasAttribute('part'))
+                mark.setAttribute('part', 'highlight');
+        }
+    }
+    return resolved;
+}
+/**
+ * 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 `<lr-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).
+ */
+export function hitTestHighlightRanges(ranges, x, y) {
+    for (let i = ranges.length - 1; i >= 0; i--) {
+        const hit = ranges[i];
+        if (!hit)
+            continue; // unreachable: counted loop, i is in [0, length - 1]
+        for (const rect of hit.range.getClientRects()) {
+            if (x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom)
+                return hit.id;
+        }
+    }
+    return null;
+}
+// -- rendering ------------------------------------------------------------------------------------
+/** The `href` of the rendered link a click landed on, when `internal-link-prefix` claims it --
+ *  `null` for every other click, including one on an ordinary external link.
+ *
+ *  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`. */
+export function internalLinkHrefFrom(e, prefix) {
+    if (!prefix)
+        return null;
+    const anchor = e.composedPath().find((el) => el instanceof HTMLAnchorElement);
+    if (!anchor)
+        return null;
+    const href = anchor.getAttribute('href') ?? '';
+    return href.startsWith(prefix) ? href : null;
+}
+/** The rendered tree both variants produce: one `[part="content"]` wrapper plus the anchor-target
+ *  live region. Only non-empty content is focusable -- an empty document is not a scrollable region
+ *  worth a tab stop. */
+export function renderMarkdownContent(options) {
+    const isFallback = options.renderedHtml === null;
+    // Indented two levels deeper than this function body on purpose. `[part='content'][data-fallback]`
+    // is `white-space: pre-wrap` (markdown.styles.ts), so the literal indentation around the binding
+    // below is *rendered* whitespace in the plain-text fallback state -- keeping the exact text both
+    // class files used before the extraction keeps that state pixel-identical.
+    // prettier-ignore
+    return html `
+      <div
+        part="content"
+        role="document"
+        tabindex=${options.content.trim() ? '0' : nothing}
+        aria-label=${options.hostAriaLabel || nothing}
+        ?data-fallback=${isFallback}
+        @click=${options.onClick}
+      >
+        ${isFallback ? options.content : unsafeHTML(options.renderedHtml)}
+      </div>
+      ${options.liveRegion}
+    `;
+}
 //# sourceMappingURL=markdown-shared.js.map