@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/markdown/markdown-loader.js

@@ -1,4 +1,9 @@
 let deps;
+// Populated the instant `deps` settles (inside `loadMarkdownDeps()` below) so
+// `getMarkdownDepsIfLoaded()` can hand one back synchronously -- the whole
+// point of that function, since `deps` itself is a Promise and awaiting it
+// always costs at least one microtask, even once already resolved.
+let resolvedDeps;
 /**
  * Independently loads the optional peer dependencies `marked` (Markdown
  * parsing) and `dompurify` (HTML sanitizing), mirroring `chart-loader.ts`'s
@@ -34,10 +39,40 @@ export async function loadMarkdownAndSanitizer(importMarked = () => import('mark
  * independently). Cached the same way `chart-loader.ts`/`map-loader.ts`
  * cache their promise, so every `<lyra-markdown>` instance on a page shares
  * one load.
+ *
+ * The dynamic `import()` inside `loadMarkdownAndSanitizer()` is always
+ * asynchronous — even when both peers are already installed and resolve
+ * without error — so every `<lyra-markdown>` that calls this from
+ * `connectedCallback()` paints its plain-text fallback (`data-fallback` on
+ * the `content` part) for at least one microtask before the real rendered
+ * output replaces it. That window is unconditional, not just a failure
+ * path: it ends only once this promise settles. A consumer that wants to
+ * skip it can set `eager-load` on `<lyra-markdown>`, which calls
+ * `getMarkdownDepsIfLoaded()` below instead of awaiting this function —
+ * see that property's doc for what "already warm" means in practice.
  */
 export function loadMarkdownDeps() {
     if (!deps) {
-        deps = loadMarkdownAndSanitizer();
+        deps = loadMarkdownAndSanitizer().then((resolved) => {
+            resolvedDeps = resolved;
+            return resolved;
+        });
     }
     return deps;
 }
+/**
+ * Synchronous companion to `loadMarkdownDeps()`: returns the same
+ * module-level cached `MarkdownDeps` if some earlier call to
+ * `loadMarkdownDeps()` — from any `<lyra-markdown>` instance on the page, or
+ * a consumer priming it directly at startup — has already settled by the
+ * time this is called, or `undefined` if the cache isn't warm yet (nothing
+ * has called `loadMarkdownDeps()` before, or it's still in flight). Used by
+ * `eager-load` to skip the dynamic `import()`'s async hop in the common case
+ * where the peers are already loaded; it cannot make the *very first*
+ * `<lyra-markdown>` on a page synchronous, since that first call is what
+ * populates the cache in the first place.
+ */
+export function getMarkdownDepsIfLoaded() {
+    return resolvedDeps;
+}
+//# sourceMappingURL=markdown-loader.js.map

package/dist/components/markdown/markdown-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-loader.js","sourceRoot":"","sources":["../../../src/components/markdown/markdown-loader.ts"],"names":[],"mappings":"AAaA,IAAI,IAAuC,CAAC;AAE5C,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,mEAAmE;AACnE,IAAI,YAAsC,CAAC;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,YAAY,GAAmC,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,CAA6B,EACjG,eAAe,GAAgD,GAAG,EAAE,CAClE,MAAM,CAAC,WAAW,CAA0C;IAE9D,IAAI,MAAmC,CAAC;IACxC,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,YAAY,EAAE,CAAC;IAChC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CACV,oHAAoH,EACpH,GAAG,CACJ,CAAC;IACJ,CAAC;IAED,IAAI,SAAsC,CAAC;IAC3C,IAAI,CAAC;QACH,SAAS,GAAG,CAAC,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC;IAChD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CACV,wGAAwG;YACtG,wGAAwG,EAC1G,GAAG,CACJ,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,gBAAgB;IAC9B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,IAAI,GAAG,wBAAwB,EAAE,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;YAClD,YAAY,GAAG,QAAQ,CAAC;YACxB,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/dist/components/markdown/markdown.class.d.ts

@@ -0,0 +1,129 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+/**
+ * `<lyra-markdown>` — sanitized Markdown-to-HTML rendering (GFM tables,
+ * fenced code blocks, links, blockquotes) 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.
+ *
+ * @customElement lyra-markdown
+ * @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. `detail: { error: unknown }`.
+ * @csspart content - The wrapper around the rendered (or plain-text
+ *   fallback) output.
+ * @csspart heading - Every rendered `<h1>`–`<h6>` (shifted by
+ *   `heading-offset`).
+ * @csspart code-block - Every rendered fenced/indented `<pre>`.
+ * @csspart link - Every rendered `<a>`.
+ * @csspart table - Every rendered `<table>`.
+ * @csspart blockquote - Every rendered `<blockquote>`.
+ * @csspart img - Every rendered `<img>`.
+ */
+export interface LyraMarkdownEventMap {
+    'lyra-render-error': CustomEvent<{
+        error: unknown;
+    }>;
+    'lyra-link-click': CustomEvent<{
+        href: string;
+        internal: boolean;
+    }>;
+}
+export declare class LyraMarkdown extends LyraElement<LyraMarkdownEventMap> {
+    static styles: import("lit").CSSResultGroup[];
+    /** The Markdown source to render. */
+    content: string;
+    /** 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. */
+    sanitize: boolean;
+    /** Enable GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists). */
+    gfm: boolean;
+    /** `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. */
+    linkTarget: string | null;
+    /** 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. */
+    internalLinkPrefix: string;
+    /** 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. */
+    headingOffset: number;
+    /** 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. */
+    eagerLoad: boolean;
+    /** Forward-compatible hint for a dedicated streaming renderer expected to
+     *  build on this component later (coalescing partial tokens as they
+     *  arrive) — setting it has no rendering effect yet. Reflects so a
+     *  consumer can already target `lyra-markdown[streaming]` in CSS ahead of
+     *  that behavior landing. */
+    streaming: boolean;
+    private renderedHtml;
+    private deps?;
+    connectedCallback(): void;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(): void;
+    private renderMarkdown;
+    private applyFallback;
+    private parseMarkdown;
+    private onContentClick;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-markdown': LyraMarkdown;
+    }
+}
+//# sourceMappingURL=markdown.class.d.ts.map

package/dist/components/markdown/markdown.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.class.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/markdown.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAoC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,WAAW,oBAAoB;IACnC,mBAAmB,EAAE,WAAW,CAAC;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACrD,iBAAiB,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrE;AACD,qBAAa,YAAa,SAAQ,WAAW,CAAC,oBAAoB,CAAC;IACjE,MAAM,CAAC,MAAM,iCAAgC;IAE7C,qCAAqC;IACzB,OAAO,SAAM;IAEzB;;4CAEwC;IACX,QAAQ,UAAQ;IAE7C,sFAAsF;IACzD,GAAG,UAAQ;IAExC;;;;2EAIuE;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAY;IAE7E;;;6CAGyC;IACQ,kBAAkB,SAAM;IAEzE;;;;;;4EAMwE;IACf,aAAa,SAAK;IAE3E;;;;;;;;;;;;6EAYyE;IACnB,SAAS,UAAS;IAExE;;;;iCAI6B;IACe,SAAS,UAAS;IAMrD,OAAO,CAAC,YAAY,CAAuB;IAEpD,OAAO,CAAC,IAAI,CAAC,CAAe;IAE5B,iBAAiB,IAAI,IAAI,CA2BxB;IAMD,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAgBlD;IAED,SAAS,CAAC,OAAO,IAAI,IAAI,CAMxB;IAED,OAAO,CAAC,cAAc;IA6CtB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,aAAa;IAsGrB,OAAO,CAAC,cAAc,CAapB;IAEF,MAAM,IAAI,cAAc,CAOvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,eAAe,EAAE,YAAY,CAAC;KAC/B;CACF"}

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

@@ -0,0 +1,354 @@
+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 { loadMarkdownDeps, getMarkdownDepsIfLoaded } from './markdown-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;
+    }
+}
+export class LyraMarkdown extends LyraElement {
+    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;
+        /** 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;
+        /** Forward-compatible hint for a dedicated streaming renderer expected to
+         *  build on this component later (coalescing partial tokens as they
+         *  arrive) — setting it has no rendering effect yet. Reflects so a
+         *  consumer can already target `lyra-markdown[streaming]` in CSS ahead of
+         *  that behavior landing. */
+        this.streaming = false;
+        // `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;
+        // 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 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]; }
+    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();
+        });
+    }
+    // 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) {
+        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')) {
+            this.renderMarkdown();
+        }
+    }
+    updated() {
+        if (this.deps) {
+            this.removeAttribute('aria-busy');
+        }
+        else {
+            this.setAttribute('aria-busy', 'true');
+        }
+    }
+    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;
+        }
+        let rawHtml;
+        try {
+            rawHtml = this.parseMarkdown(deps.marked);
+        }
+        catch (error) {
+            this.applyFallback(error);
+            return;
+        }
+        if (!this.sanitize) {
+            // Consumer explicitly opted out of sanitization — dompurify's
+            // presence or absence is irrelevant to this path.
+            this.renderedHtml = rawHtml;
+            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.
+        this.renderedHtml = deps.DOMPurify.sanitize(rawHtml, { ADD_ATTR: ['target'] });
+    }
+    applyFallback(error) {
+        this.renderedHtml = null;
+        this.emit('lyra-render-error', { error });
+    }
+    parseMarkdown(marked) {
+        // 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;
+        const headingOffset = this.headingOffset;
+        const instance = new marked.Marked();
+        // 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));
+                    return `<h${depth} part="heading">${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);
+                    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}>`;
+                },
+            },
+        });
+        return instance.parse(this.content, { gfm: this.gfm, async: false });
+    }
+    render() {
+        const isFallback = this.renderedHtml === null;
+        return html `
+      <div part="content" ?data-fallback=${isFallback} @click=${this.onContentClick}>
+        ${isFallback ? this.content : unsafeHTML(this.renderedHtml)}
+      </div>
+    `;
+    }
+}
+__decorate([
+    property()
+], LyraMarkdown.prototype, "content", void 0);
+__decorate([
+    property({ type: Boolean })
+], LyraMarkdown.prototype, "sanitize", void 0);
+__decorate([
+    property({ type: Boolean })
+], LyraMarkdown.prototype, "gfm", void 0);
+__decorate([
+    property({ attribute: 'link-target' })
+], LyraMarkdown.prototype, "linkTarget", void 0);
+__decorate([
+    property({ attribute: 'internal-link-prefix' })
+], LyraMarkdown.prototype, "internalLinkPrefix", void 0);
+__decorate([
+    property({ type: Number, attribute: 'heading-offset' })
+], LyraMarkdown.prototype, "headingOffset", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'eager-load' })
+], LyraMarkdown.prototype, "eagerLoad", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraMarkdown.prototype, "streaming", void 0);
+__decorate([
+    state()
+], LyraMarkdown.prototype, "renderedHtml", void 0);
+//# sourceMappingURL=markdown.class.js.map

package/dist/components/markdown/markdown.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.class.js","sourceRoot":"","sources":["../../../src/components/markdown/markdown.class.ts"],"names":[],"mappings":"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"}

package/dist/components/markdown/markdown.d.ts

@@ -1,81 +1,2 @@
-import { type TemplateResult, type PropertyValues } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-/**
- * `<lyra-markdown>` — sanitized Markdown-to-HTML rendering (GFM tables,
- * fenced code blocks, links, blockquotes) 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.
- *
- * `heading`/`code`/`blockquote`/`table`/`link` 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.
- *
- * @customElement lyra-markdown
- * @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. `detail: { error: unknown }`.
- * @csspart content - The wrapper around the rendered (or plain-text
- *   fallback) output.
- * @csspart heading - Every rendered `<h1>`–`<h6>`.
- * @csspart code-block - Every rendered fenced/indented `<pre>`.
- * @csspart link - Every rendered `<a>`.
- * @csspart table - Every rendered `<table>`.
- * @csspart blockquote - Every rendered `<blockquote>`.
- */
-export declare class LyraMarkdown extends LyraElement {
-    static styles: import("lit").CSSResultGroup[];
-    /** The Markdown source to render. */
-    content: string;
-    /** 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. */
-    sanitize: boolean;
-    /** Enable GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists). */
-    gfm: boolean;
-    /** `target` applied to every rendered `<a>`; `rel="noopener noreferrer"` is
-     *  always added alongside it regardless of this value. */
-    linkTarget: string;
-    /** 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. */
-    internalLinkPrefix: string;
-    /** Forward-compatible hint for a dedicated streaming renderer expected to
-     *  build on this component later (coalescing partial tokens as they
-     *  arrive) — setting it has no rendering effect yet. Reflects so a
-     *  consumer can already target `lyra-markdown[streaming]` in CSS ahead of
-     *  that behavior landing. */
-    streaming: boolean;
-    private renderedHtml;
-    private deps?;
-    connectedCallback(): void;
-    protected willUpdate(changed: PropertyValues): void;
-    protected updated(): void;
-    private renderMarkdown;
-    private applyFallback;
-    private parseMarkdown;
-    private onContentClick;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lyra-markdown': LyraMarkdown;
-    }
-}
+export * from './markdown.class.js';
+//# sourceMappingURL=markdown.d.ts.map

package/dist/components/markdown/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/markdown.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}