ngwr 10.2.1 → 11.1.0

package/fesm2022/ngwr-markdown.mjs

@@ -0,0 +1,1492 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { NgTemplateOutlet } from '@angular/common';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, signal, Injectable, DestroyRef, input, computed, effect, ViewEncapsulation, Component, makeEnvironmentProviders } from '@angular/core';
+import { useConfigValue } from 'ngwr/config';
+import { WrCopyToClipboard } from 'ngwr/directives';
+import { useI18nText } from 'ngwr/i18n';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Markdown to a node tree. No HTML anywhere in the pipeline.
+ *
+ * **Why a parser in a component library that has one runtime dependency.** The
+ * alternative was `marked` or `markdown-it`, and both produce an HTML string —
+ * which then has to reach the DOM through `[innerHTML]`, which means Angular's
+ * sanitizer on the hot path of the one component whose input is untrusted by
+ * definition, and `bypassSecurityTrustHtml` the moment syntax highlighting is
+ * wanted. A node tree renders through ordinary Angular bindings instead: every
+ * text node is a text node, every `href` goes through `SecurityContext.URL`, and
+ * nothing is ever parsed as HTML. That is worth a parser.
+ *
+ * The second reason is streaming, which no general-purpose parser is built for.
+ * See {@link WrMarkdownParseOptions.streaming}: an open fence has to render as a
+ * code block, and a half-typed `**` must not flash on screen as literal
+ * asterisks.
+ *
+ * **The subset, stated rather than discovered.** ATX headings, paragraphs,
+ * fenced code, blockquotes, bullet / ordered / task lists (nested), GFM tables,
+ * thematic breaks; inline code, strong, emphasis, strikethrough, links, images,
+ * autolinks (bracketed and bare), hard breaks, backslash escapes.
+ *
+ * Deliberately absent, each for a reason:
+ *
+ * - **Raw HTML is escaped, never rendered.** A markdown renderer whose input is
+ *   model output or user comments cannot pass `<img onerror>` through and call
+ *   it a feature. `<div>` in equals `<div>` on screen, as text.
+ * - **Indented (four-space) code blocks.** In a document that also has nested
+ *   lists, indentation is structural, and the ambiguity resolves against the
+ *   author roughly every time: a wrapped list continuation becomes a code block.
+ *   Fences are unambiguous, and fences are what generators emit.
+ * - **Setext headings** (`===` / `---` under a line). `---` is a thematic break
+ *   here, always. The dual meaning is a well-known trap and the underline form
+ *   is essentially unused in generated markdown.
+ * - **Reference links, footnotes, definition lists.** They need a second pass
+ *   over a document that, mid-stream, is not all there yet.
+ *
+ * Two known deviations, kept rather than fixed, because the cure looked worse than
+ * the disease:
+ *
+ * - **A blank line inside a NESTED list marks the outer list loose too**, so
+ *   `- a` / `  - b` / blank / `  - c` / `- d` double-spaces the outer items.
+ *   CommonMark scopes looseness per list; telling the two apart needs to know
+ *   which level a blank line belongs to, and the indentation alone does not say —
+ *   content at the item's own indent can belong either to the item or to a
+ *   sublist's sibling. The visible cost is spacing.
+ * - **An unmatched `[` is not linear.** The scan is bounded per opener
+ *   ({@link MAX_LABEL_LENGTH}) and short-circuits once the source is known to hold
+ *   no `]` at all, which took `'['.repeat(100000)` from 8s to 0.2s — but a
+ *   document that is mostly open brackets with a `]` somewhere still pays per
+ *   opener. Real prose does not have that shape.
+ *
+ * @param source markdown text
+ * @returns block nodes, ready to render
+ */
+function parseMarkdown(source, options = {}) {
+    if (!source)
+        return [];
+    const ctx = newContext(options.streaming ?? false);
+    const blocks = parseBlocks(normalize(source).split('\n'), 0, ctx);
+    return ctx.streaming ? applyStreamingTail(blocks) : blocks;
+}
+/**
+ * How deep a quote / list nest may go before the parser stops recursing.
+ *
+ * Not a taste limit: each level is a recursive call over its own slice of the
+ * lines, so a pathological input (`> > > > …` a thousand deep, which is four
+ * kilobytes of text) is a stack overflow inside a change-detection pass. Past
+ * the cap the content renders as paragraphs — visible, harmless, and nothing a
+ * real document reaches.
+ */
+const MAX_DEPTH = 12;
+/**
+ * How many columns of a table are rendered.
+ *
+ * The same class of protection as {@link MAX_DEPTH}, for the same reason, and it
+ * was measured rather than guessed: every row is padded to the header's width, so
+ * cells scale as columns × rows while the input scales as columns + rows. A 38 KB
+ * document — a 10,001-pipe header and 2,000 short rows, which is what a truncated
+ * table from a model looks like — produced **20 million cells** in 4.5 seconds,
+ * inside a `computed` that re-runs on every streamed chunk. No real table is wider
+ * than this; a wider one renders its first 128 columns.
+ */
+const MAX_TABLE_COLUMNS = 128;
+function newContext(streaming) {
+    return {
+        streaming,
+        slugs: new Map(),
+        noCloser: new Map(),
+        noBracket: { from: Number.POSITIVE_INFINITY },
+        inLink: false,
+    };
+}
+const FENCE_RE = /^( {0,3})(`{3,}|~{3,})[ \t]*(.*)$/;
+// The closing `#` run must be PRECEDED by whitespace, or `# C#` loses its sharp
+// and `#######` (seven, not a heading in any dialect) matches as an empty h6.
+const HEADING_RE = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/;
+const RULE_RE = /^ {0,3}(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const QUOTE_RE = /^ {0,3}>[ \t]?(.*)$/;
+const LIST_RE = /^( *)([-*+]|\d{1,9}[.)])(?:([ \t]+)(.*)|[ \t]*)$/;
+const TASK_RE = /^\[([ xX])\](?:[ \t]+(.*)|[ \t]*)$/;
+const TABLE_DELIM_RE = /^ {0,3}\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+/**
+ * `\r\n` and lone `\r` out; tabs in the INDENT to four spaces, so indent maths is
+ * in one unit.
+ *
+ * The whole leading whitespace run, not just a line-initial tab: `'  \t- b'` is
+ * two spaces and a tab, and `parseList` measures indentation in characters, so a
+ * tab counted as one column made mixed indentation parse as literal text.
+ */
+function normalize(source) {
+    return source.replace(/\r\n?/g, '\n').replace(/^[ \t]+/gm, indent => indent.replace(/\t/g, '    '));
+}
+/** Does this line begin a block that interrupts a paragraph or a list item? */
+function startsBlock(line) {
+    return (FENCE_RE.test(line) || HEADING_RE.test(line) || RULE_RE.test(line) || QUOTE_RE.test(line) || LIST_RE.test(line));
+}
+/**
+ * Does this line end the paragraph it follows?
+ *
+ * Every block start does, except the two lists CommonMark says cannot interrupt
+ * one: an ordered item whose number is not 1, and an item with no content. The
+ * first rule exists for a single shape, and it is a shape prose actually has —
+ * "The year was" / "1986. It was a good year." must not become a list numbered
+ * from 1986.
+ */
+function interruptsParagraph(line) {
+    const list = matchListStart(line);
+    if (list && !RULE_RE.test(line)) {
+        return list.content.trim() !== '' && (!list.ordered || list.number === 1);
+    }
+    return startsBlock(line);
+}
+function matchListStart(line) {
+    const match = LIST_RE.exec(line);
+    if (!match)
+        return null;
+    const [, indent, marker, spaces, content] = match;
+    const ordered = !/^[-*+]$/.test(marker);
+    return {
+        indent: indent.length,
+        ordered,
+        number: ordered ? Number.parseInt(marker, 10) : 1,
+        content: content ?? '',
+        // An empty item (`-` alone) has no run of spaces to measure, so assume one.
+        contentIndent: indent.length + marker.length + (spaces?.length ?? 1),
+    };
+}
+function parseBlocks(lines, depth, ctx) {
+    if (depth >= MAX_DEPTH) {
+        const text = lines.join('\n').trim();
+        return text ? [{ kind: 'paragraph', inlines: inlines(text, 0, ctx) }] : [];
+    }
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (!line.trim()) {
+            i++;
+            continue;
+        }
+        const fence = FENCE_RE.exec(line);
+        if (fence) {
+            const [, indent, marker, info] = fence;
+            const body = [];
+            const closer = new RegExp(`^ {0,3}\\${marker[0]}{${marker.length},}[ \\t]*$`);
+            let closed = false;
+            i++;
+            while (i < lines.length) {
+                if (closer.test(lines[i])) {
+                    closed = true;
+                    i++;
+                    break;
+                }
+                // The opening fence's own indentation is not part of the code.
+                body.push(stripIndent(lines[i], indent.length));
+                i++;
+            }
+            out.push({
+                kind: 'code',
+                language: info.trim().split(/\s+/)[0].toLowerCase() || null,
+                code: body.join('\n'),
+                closed,
+            });
+            continue;
+        }
+        const heading = HEADING_RE.exec(line);
+        if (heading) {
+            const text = (heading[2] ?? '').trim();
+            const content = inlines(text, 0, ctx);
+            out.push({
+                kind: 'heading',
+                level: heading[1].length,
+                inlines: content,
+                // Slugged from the rendered TEXT, not from the markdown: `## See [docs](url)`
+                // was producing `see-docshttpsxdeva`, an anchor nobody can link to.
+                id: uniqueSlug(plainText(content), ctx),
+            });
+            i++;
+            continue;
+        }
+        if (RULE_RE.test(line)) {
+            out.push({ kind: 'rule' });
+            i++;
+            continue;
+        }
+        if (QUOTE_RE.test(line)) {
+            const body = [];
+            while (i < lines.length) {
+                const quoted = QUOTE_RE.exec(lines[i]);
+                if (quoted) {
+                    body.push(quoted[1]);
+                    i++;
+                    continue;
+                }
+                // Lazy continuation: an unmarked, non-blank line still belongs to the
+                // quote unless it starts a block of its own.
+                if (!lines[i].trim() || startsBlock(lines[i]))
+                    break;
+                body.push(lines[i].trimStart());
+                i++;
+            }
+            out.push({ kind: 'quote', children: parseBlocks(body, depth + 1, ctx) });
+            continue;
+        }
+        if (matchListStart(line)) {
+            const [list, next] = parseList(lines, i, depth, ctx);
+            out.push(list);
+            i = next;
+            continue;
+        }
+        if (isTableStart(lines, i)) {
+            const [table, next] = parseTable(lines, i, ctx);
+            out.push(table);
+            i = next;
+            continue;
+        }
+        const paragraph = [line];
+        i++;
+        while (i < lines.length && lines[i].trim() && !interruptsParagraph(lines[i])) {
+            // A delimiter row two lines in turns the paragraph into a table header.
+            if (isTableStart(lines, i))
+                break;
+            paragraph.push(lines[i]);
+            i++;
+        }
+        out.push({ kind: 'paragraph', inlines: inlines(paragraph.join('\n').trim(), 0, ctx) });
+    }
+    return out;
+}
+/**
+ * A table header, or a sentence that happens to contain a pipe.
+ *
+ * GFM's own rule, and the one this used to be missing: "the header row must match
+ * the delimiter row in the number of cells. If not, a table will not be
+ * recognized." Without the count check, `Use the | character` followed by `---`
+ * became a two-column table with an empty body — swallowing both the sentence and
+ * the thematic break, and contradicting this file's own decision that `---` is
+ * always a rule.
+ */
+function isTableStart(lines, at) {
+    const header = lines[at];
+    const delimiter = lines[at + 1];
+    if (!header?.includes('|') || delimiter === undefined || !TABLE_DELIM_RE.test(delimiter))
+        return false;
+    return splitRow(header).length === splitRow(delimiter).length;
+}
+/** Remove up to `width` leading spaces — never more, so relative indent survives. */
+function stripIndent(line, width) {
+    let cut = 0;
+    while (cut < width && line[cut] === ' ')
+        cut++;
+    return line.slice(cut);
+}
+function parseList(lines, from, depth, ctx) {
+    const first = matchListStart(lines[from]);
+    const items = [];
+    let loose = false;
+    let i = from;
+    while (i < lines.length) {
+        // A thematic break wins over a list item, which is CommonMark's rule and not
+        // a nicety: `* * *` matches the bullet pattern, so without this `* a`,
+        // `* * *`, `* b` is one list with a phantom nesting level where the divider
+        // was, and the `<hr>` is gone.
+        if (RULE_RE.test(lines[i]))
+            break;
+        const start = matchListStart(lines[i]);
+        // A different marker family starts a NEW list rather than continuing this
+        // one — `- a` then `1. b` is two lists, and rendering it as one silently
+        // renumbers the author's content.
+        if (start?.ordered !== first.ordered || start.indent > first.indent + 3)
+            break;
+        const body = [start.content];
+        let blanks = 0;
+        i++;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (!line.trim()) {
+                blanks++;
+                i++;
+                continue;
+            }
+            const indent = line.length - line.trimStart().length;
+            if (indent >= start.contentIndent) {
+                // A blank line followed by more of the same item makes the list loose,
+                // which is what decides whether items get `<p>` wrappers.
+                if (blanks > 0) {
+                    body.push(...Array(blanks).fill(''));
+                    loose = true;
+                    blanks = 0;
+                }
+                body.push(stripIndent(line, start.contentIndent));
+                i++;
+                continue;
+            }
+            // Out-dented: a sibling item, another block, or lazy continuation of this
+            // item's paragraph. After a blank line only a sibling can follow.
+            if (blanks > 0 || matchListStart(line) || startsBlock(line))
+                break;
+            body.push(line.trimStart());
+            i++;
+        }
+        const nextIsSibling = i < lines.length && matchListStart(lines[i]) !== null;
+        if (blanks > 0 && nextIsSibling)
+            loose = true;
+        items.push(makeItem(body, depth, ctx));
+        if (blanks > 0 && !nextIsSibling)
+            break;
+    }
+    return [{ kind: 'list', ordered: first.ordered, start: first.number, tight: !loose, items }, i];
+}
+function makeItem(body, depth, ctx) {
+    const task = TASK_RE.exec(body[0] ?? '');
+    const lines = task ? [task[2] ?? '', ...body.slice(1)] : body;
+    return {
+        children: parseBlocks(lines, depth + 1, ctx),
+        checked: task ? task[1].toLowerCase() === 'x' : null,
+    };
+}
+function parseTable(lines, from, ctx) {
+    const head = splitRow(lines[from]).slice(0, MAX_TABLE_COLUMNS);
+    const align = splitRow(lines[from + 1]).map((spec) => {
+        const left = spec.startsWith(':');
+        const right = spec.endsWith(':');
+        if (left && right)
+            return 'center';
+        if (right)
+            return 'end';
+        if (left)
+            return 'start';
+        return null;
+    });
+    const rows = [];
+    let i = from + 2;
+    while (i < lines.length) {
+        const line = lines[i];
+        // GFM ends a table at a blank line, a line that starts another block, or
+        // anything without a cell divider.
+        if (!line.trim() || !line.includes('|') || startsBlock(line))
+            break;
+        rows.push(normalizeCells(splitRow(line), head.length, ctx));
+        i++;
+    }
+    return [
+        {
+            kind: 'table',
+            head: head.map(cell => ({ inlines: inlines(cell, 0, ctx) })),
+            rows,
+            align: normalizeAlign(align, head.length),
+        },
+        i,
+    ];
+}
+/** Split on unescaped pipes, dropping the optional leading and trailing one. */
+function splitRow(line) {
+    const cells = [];
+    let current = '';
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] === '\\' && line[i + 1] === '|') {
+            current += '|';
+            i++;
+            continue;
+        }
+        if (line[i] === '|') {
+            cells.push(current);
+            current = '';
+            continue;
+        }
+        current += line[i];
+    }
+    cells.push(current);
+    if (cells.length > 1 && !cells[0].trim())
+        cells.shift();
+    if (cells.length > 1 && !cells[cells.length - 1].trim())
+        cells.pop();
+    return cells.map(cell => cell.trim());
+}
+/** A row shorter than the header gets empty cells; a longer one is truncated. */
+function normalizeCells(cells, width, ctx) {
+    return Array.from({ length: width }, (_, index) => ({ inlines: inlines(cells[index] ?? '', 0, ctx) }));
+}
+function normalizeAlign(align, width) {
+    return Array.from({ length: width }, (_, index) => align[index] ?? null);
+}
+/**
+ * GitHub-compatible heading slug: lowercase, punctuation dropped, spaces to dashes.
+ *
+ * `_` and `-` are KEPT, which is what GitHub does — stripping the underscore broke
+ * every published `#snake_case` anchor.
+ */
+function slug(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s_-]/gu, '')
+        .trim()
+        .replace(/\s+/g, '-');
+}
+/**
+ * The slug, with a counter when the document repeats a title.
+ *
+ * Two `## Fixes` in one changelog produced two `id="fixes"`, which is invalid and
+ * makes `#fixes` resolve to whichever came first. GitHub appends `-1`, `-2`; so
+ * does this. An empty slug (a heading of pure emoji, or no text at all) stays
+ * empty and the renderer binds no `id`.
+ */
+function uniqueSlug(text, ctx) {
+    const base = slug(text);
+    if (!base)
+        return '';
+    const used = ctx.slugs.get(base) ?? 0;
+    ctx.slugs.set(base, used + 1);
+    return used === 0 ? base : `${base}-${used}`;
+}
+// ---------------------------------------------------------------------------
+// Inline
+// ---------------------------------------------------------------------------
+// Every ASCII punctuation character, which is what CommonMark allows. The
+// hand-written subset left `\$`, `\&`, `\%` and eight others rendering with their
+// backslash — and `\$` is what generators emit to keep a dollar out of math mode.
+const ESCAPABLE = /[!-/:-@[-`{-~]/;
+const SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
+const ALLOWED_SCHEMES = new Set(['http', 'https', 'mailto', 'tel', 'ftp']);
+const DATA_IMAGE_RE = /^data:image\/(?:png|jpe?g|gif|webp|avif);base64,[a-z0-9+/=]+$/i;
+const AUTOLINK_RE = /^<((?:https?|mailto|tel):[^>\s]+)>/i;
+/** `<destination>` — markdown's way of putting a space in a URL. */
+const ANGLE_DEST_RE = /^<([^<>]*)>(?:\s+["'(](.*)["')])?$/;
+/** CommonMark's own cap on a link label, which is also what bounds the scan. */
+const MAX_LABEL_LENGTH = 999;
+const BARE_URL_RE = /^https?:\/\/[^\s<>[\]()]*(?:\([^\s<>()]*\)[^\s<>[\]()]*)*/i;
+const EMAIL_AUTOLINK_RE = /^<([^\s@<>]+@[^\s@<>.]+\.[^\s@<>]+)>/;
+/**
+ * A URL safe to put in `href` / `src`, or `null` to render the link as plain text.
+ *
+ * Two layers, and both are wanted. Angular sanitizes `[href]` bindings itself,
+ * but its answer to a hostile URL is the string `unsafe:javascript:…` in a live
+ * anchor — a link that looks real, is announced as a link, and does nothing.
+ * Refusing it here means the label renders as text instead, which is honest.
+ *
+ * Whitespace and control characters are stripped before the scheme is read,
+ * because `java\nscript:` and `java script:` are the same URL to a browser and
+ * different strings to a naive check.
+ */
+function safeMarkdownUrl(raw, kind) {
+    const url = raw.trim();
+    // Whitespace and control characters only: a hyphen has no business being
+    // stripped out of a host name. Written as escapes rather than literal bytes —
+    // a raw NUL inside a regex literal makes the file binary to every text tool.
+    // Stripping control characters is the entire point here: a browser ignores them
+    // before resolving the scheme, so a check that reads the raw string sees a
+    // relative path and waves `java\u0000script:` straight through.
+    // eslint-disable-next-line no-control-regex
+    const bare = url.replace(/[\s\u0000-\u001f\u007f]/g, '');
+    const scheme = SCHEME_RE.exec(bare);
+    // No scheme at all: relative path, `#anchor`, `//host` — nothing executable.
+    if (!scheme)
+        return url;
+    const name = scheme[1].toLowerCase();
+    // `data:` is an image-only allowance, and only for raster types: an SVG can
+    // carry script, and `data:text/html` is a same-origin document.
+    if (name === 'data')
+        return kind === 'image' && DATA_IMAGE_RE.test(bare) ? bare : null;
+    return ALLOWED_SCHEMES.has(name) ? url : null;
+}
+/** Inline markdown to nodes. */
+function parseInlines(source, options = {}) {
+    return inlines(source, 0, newContext(options.streaming ?? false));
+}
+function inlines(source, depth, ctx) {
+    if (depth >= MAX_DEPTH)
+        return source ? [{ kind: 'text', value: source }] : [];
+    const out = [];
+    let text = '';
+    let i = 0;
+    const flush = () => {
+        if (text) {
+            out.push({ kind: 'text', value: text });
+            text = '';
+        }
+    };
+    while (i < source.length) {
+        const char = source[i];
+        if (char === '\\') {
+            // A backslash before a newline is a hard break; before punctuation, an escape.
+            if (source[i + 1] === '\n') {
+                flush();
+                out.push({ kind: 'break' });
+                i += 2;
+                continue;
+            }
+            if (i + 1 < source.length && ESCAPABLE.test(source[i + 1])) {
+                text += source[i + 1];
+                i += 2;
+                continue;
+            }
+        }
+        if (char === '\n') {
+            // Two trailing spaces are markdown's hard break. `endsWith`, not
+            // `/[ ]{2,}$/.test(text)`: that regex has no start anchor, so it retries
+            // from every position of the accumulated paragraph, which made paragraph
+            // parsing quadratic. On a 161 KB document a CPU profile put 3306 ms of 3378
+            // ms of total self-time in that one test — and it is re-paid on every
+            // streamed chunk.
+            const hard = text.endsWith('  ');
+            if (hard) {
+                text = text.replace(/[ ]+$/, '');
+                flush();
+                out.push({ kind: 'break' });
+            }
+            else {
+                // A soft break is whitespace; CSS collapses it like any other.
+                text += '\n';
+            }
+            i++;
+            continue;
+        }
+        if (char === '`') {
+            const run = /^`+/.exec(source.slice(i))[0];
+            const close = findCodeClose(source, i + run.length, run);
+            if (close !== -1) {
+                flush();
+                out.push({ kind: 'code', value: codeSpanValue(source.slice(i + run.length, close)) });
+                i = close + run.length;
+                continue;
+            }
+        }
+        if (char === '<') {
+            const auto = AUTOLINK_RE.exec(source.slice(i));
+            if (auto) {
+                // `ctx.inLink`: CommonMark forbids a link inside a link, and nothing else
+                // stops it here — a tree built with DOM APIs nests the `<a>` an HTML
+                // parser would have thrown away, which is invalid markup and an axe
+                // `nested-interactive` violation at serious level.
+                const href = ctx.inLink ? null : safeMarkdownUrl(auto[1], 'link');
+                flush();
+                out.push(href
+                    ? { kind: 'link', href, title: null, children: [{ kind: 'text', value: auto[1] }] }
+                    : { kind: 'text', value: auto[1] });
+                i += auto[0].length;
+                continue;
+            }
+            const email = EMAIL_AUTOLINK_RE.exec(source.slice(i));
+            if (email) {
+                // Through `safeMarkdownUrl` like every other href: built by hand, this was
+                // the one destination that skipped the control-character strip, which the
+                // component's own JSDoc promises for all of them.
+                const href = ctx.inLink ? null : safeMarkdownUrl(`mailto:${email[1]}`, 'link');
+                flush();
+                out.push(href
+                    ? { kind: 'link', href, title: null, children: [{ kind: 'text', value: email[1] }] }
+                    : { kind: 'text', value: email[1] });
+                i += email[0].length;
+                continue;
+            }
+        }
+        if (char === '!' && source[i + 1] === '[') {
+            const link = matchLink(source, i + 1, ctx);
+            if (link) {
+                const src = safeMarkdownUrl(link.href, 'image');
+                const alt = plainText(inlines(link.label, depth + 1, { ...ctx, inLink: true }));
+                flush();
+                // A refused source leaves the alt text, which is the information the
+                // author actually wrote.
+                out.push(src ? { kind: 'image', src, alt, title: link.title } : { kind: 'text', value: alt });
+                i = link.end;
+                continue;
+            }
+        }
+        if (char === '[') {
+            const link = matchLink(source, i, ctx);
+            if (link) {
+                const href = ctx.inLink ? null : safeMarkdownUrl(link.href, 'link');
+                // The label is parsed with links SUPPRESSED, so an inner one renders as
+                // its own text — CommonMark's answer to `[a [b](c)](d)`.
+                const children = inlines(link.label, depth + 1, { ...ctx, inLink: true });
+                flush();
+                if (href)
+                    out.push({ kind: 'link', href, title: link.title, children });
+                else
+                    out.push(...children);
+                i = link.end;
+                continue;
+            }
+        }
+        if ((char === 'h' || char === 'H') && (i === 0 || !/[\w/]/.test(source[i - 1]))) {
+            const bare = ctx.inLink ? null : BARE_URL_RE.exec(source.slice(i));
+            if (bare) {
+                const url = trimUrlPunctuation(bare[0]);
+                const href = safeMarkdownUrl(url, 'link');
+                if (href) {
+                    flush();
+                    out.push({ kind: 'link', href, title: null, children: [{ kind: 'text', value: url }] });
+                    i += url.length;
+                    continue;
+                }
+            }
+        }
+        if (char === '*' || char === '_' || char === '~') {
+            const emphasis = matchEmphasis(source, i, depth, ctx);
+            if (emphasis) {
+                flush();
+                out.push(emphasis.node);
+                i = emphasis.end;
+                continue;
+            }
+        }
+        text += char;
+        i++;
+    }
+    flush();
+    return out;
+}
+/** The closing backtick run of exactly the opener's length — a longer run is not it. */
+function findCodeClose(source, from, run) {
+    for (let i = from; i < source.length; i++) {
+        if (source[i] !== '`')
+            continue;
+        let end = i;
+        while (source[end] === '`')
+            end++;
+        if (end - i === run.length)
+            return i;
+        i = end - 1;
+    }
+    return -1;
+}
+/** CommonMark strips one space from each end when both are present. */
+function codeSpanValue(raw) {
+    const value = raw.replace(/\n/g, ' ');
+    return value.length > 2 && value.startsWith(' ') && value.endsWith(' ') && value.trim() ? value.slice(1, -1) : value;
+}
+/**
+ * `[label](href "title")` starting at `source[at] === '['`.
+ *
+ * Two bounds, both load-bearing. The label scan stops at
+ * {@link MAX_LABEL_LENGTH}, which is CommonMark's own limit, and a scan that
+ * reaches the end of the source without meeting a single `]` records the fact in
+ * the context — from then on every later `[` answers in constant time. Without
+ * that, `'['.repeat(100000)` spent 8 seconds on the main thread, inside a
+ * `computed`.
+ */
+function matchLink(source, at, ctx) {
+    if (at >= ctx.noBracket.from)
+        return null;
+    let depth = 0;
+    let close = -1;
+    let sawClose = false;
+    let scannedToEnd = true;
+    for (let i = at; i < source.length; i++) {
+        if (i - at > MAX_LABEL_LENGTH) {
+            scannedToEnd = false;
+            break;
+        }
+        const char = source[i];
+        if (char === '\\') {
+            i++;
+            continue;
+        }
+        // A code span can hold an unbalanced bracket; stepping over it keeps
+        // `` [`a]b`](x) `` from ending the label early.
+        if (char === '`') {
+            const run = /^`+/.exec(source.slice(i))[0];
+            const end = findCodeClose(source, i + run.length, run);
+            if (end !== -1) {
+                i = end + run.length - 1;
+                continue;
+            }
+        }
+        if (char === '[')
+            depth++;
+        if (char === ']') {
+            sawClose = true;
+            depth--;
+            if (depth === 0) {
+                close = i;
+                break;
+            }
+        }
+    }
+    if (close === -1) {
+        // Only when the source truly holds no `]` past here: an unbalanced nest
+        // (`[[a](b)`) fails for a different reason, and memoising that would hide the
+        // valid link one character to the right.
+        if (!sawClose && scannedToEnd)
+            ctx.noBracket.from = Math.min(ctx.noBracket.from, at);
+        return null;
+    }
+    if (source[close + 1] !== '(')
+        return null;
+    let parens = 1;
+    let end = -1;
+    for (let i = close + 2; i < source.length; i++) {
+        const char = source[i];
+        if (char === '\\') {
+            i++;
+            continue;
+        }
+        if (char === '(')
+            parens++;
+        if (char === ')') {
+            parens--;
+            if (parens === 0) {
+                end = i;
+                break;
+            }
+        }
+        // A newline inside the destination means this was never a link.
+        if (char === '\n')
+            return null;
+    }
+    if (end === -1)
+        return null;
+    const target = source.slice(close + 2, end).trim();
+    const label = source.slice(at + 1, close);
+    // `<…>` around the destination is markdown's way of allowing a space in it, and
+    // it has to be unwrapped BEFORE the scheme is read: `[a](<javascript:alert(1)>)`
+    // has no scheme while the bracket is still attached, so `safeMarkdownUrl` read
+    // it as a relative path and waved it through — leaving Angular's sanitizer, the
+    // layer this file calls insufficient, as the only thing standing in the way.
+    const angled = ANGLE_DEST_RE.exec(target);
+    if (angled)
+        return { label, href: angled[1], title: angled[2] ?? null, end: end + 1 };
+    const titled = /^(\S*)\s+["'(](.*)["')]$/.exec(target);
+    return {
+        label,
+        href: titled ? titled[1] : target,
+        title: titled ? titled[2] : null,
+        end: end + 1,
+    };
+}
+/** Trailing sentence punctuation belongs to the prose, not to the bare URL. */
+function trimUrlPunctuation(url) {
+    return url.replace(/[.,;:!?'"]+$/, '');
+}
+/**
+ * Emphasis, strong and strikethrough.
+ *
+ * A pragmatic reading of CommonMark's flanking rules rather than the full
+ * algorithm: an opener may not be followed by whitespace, a closer may not be
+ * preceded by it, and `_` additionally may not sit against a word character on
+ * the outside. That last clause is the one that matters in practice — without it
+ * `snake_case_name` renders as `snake<em>case</em>name`, which is how most
+ * lightweight parsers embarrass themselves on code-adjacent prose.
+ */
+function matchEmphasis(source, at, depth, ctx) {
+    const char = source[at];
+    const run = /^(\*+|_+|~+)/.exec(source.slice(at))[0].length;
+    // `~` is strikethrough only as a pair: a single one is arithmetic, a path, or
+    // LaTeX far more often than it is emphasis.
+    if (char === '~' && run < 2)
+        return null;
+    const use = char === '~' ? 2 : Math.min(run, 2);
+    const after = source[at + run];
+    if (after === undefined || /\s/.test(after))
+        return null;
+    if (char === '_' && at > 0 && /[\p{L}\p{N}]/u.test(source[at - 1]))
+        return null;
+    // Already known to have no closer from here on. The search is monotone — the
+    // window for a later opener is a subset of this one — so one failure answers
+    // every subsequent opener of the same character, which is what turns a
+    // quadratic scan into a linear one.
+    const failedFrom = ctx.noCloser.get(char);
+    if (failedFrom !== undefined && at >= failedFrom)
+        return null;
+    for (let i = at + run; i < source.length; i++) {
+        const current = source[i];
+        if (current === '\\') {
+            i++;
+            continue;
+        }
+        if (current === '`') {
+            const backticks = /^`+/.exec(source.slice(i))[0];
+            const end = findCodeClose(source, i + backticks.length, backticks);
+            if (end !== -1) {
+                i = end + backticks.length - 1;
+                continue;
+            }
+        }
+        if (current !== char)
+            continue;
+        let end = i;
+        while (source[end] === char)
+            end++;
+        const length = end - i;
+        if (length < use || /\s/.test(source[i - 1])) {
+            i = end - 1;
+            continue;
+        }
+        if (char === '_' && end < source.length && /[\p{L}\p{N}]/u.test(source[end])) {
+            i = end - 1;
+            continue;
+        }
+        // Take `use` markers from the START of the opener and the END of the closer,
+        // so `***x***` leaves `*x*` inside the strong node and nests correctly.
+        const children = inlines(source.slice(at + use, end - use), depth + 1, ctx);
+        const kind = char === '~' ? 'del' : use === 2 ? 'strong' : 'em';
+        return { node: { kind, children }, end };
+    }
+    // No closer anywhere in this source. Recorded so the next opener of the same
+    // character does not repeat the walk.
+    //
+    // Note what does NOT happen here any more: an optimistic close. Guessing at the
+    // scanner level meant a marker 40 characters back swallowed the rest of the
+    // block — including markup that had already parsed, so an unclosed backtick ate
+    // a finished `[docs](url)` and rendered it as monospaced source. Mid-stream
+    // guessing now happens once, on the document's tail, where it can be bounded.
+    // See {@link applyStreamingTail}.
+    ctx.noCloser.set(char, Math.min(failedFrom ?? Number.POSITIVE_INFINITY, at));
+    return null;
+}
+/** Text content of an inline tree — for `alt` and for heading slugs. */
+function plainText(inlines) {
+    return inlines
+        .map(node => {
+        switch (node.kind) {
+            case 'text':
+            case 'code':
+                return node.value;
+            case 'image':
+                return node.alt;
+            case 'break':
+                return ' ';
+            default:
+                return plainText(node.children);
+        }
+    })
+        .join('');
+}
+// ---------------------------------------------------------------------------
+// Streaming
+// ---------------------------------------------------------------------------
+/**
+ * How far back from the end of the document a marker may sit and still be treated
+ * as mid-flight.
+ *
+ * The optimistic close is a GUESS, and a guess needs a blast radius. Unbounded, a
+ * `*` forty characters back turned the rest of a finished sentence into emphasis
+ * for the whole stream and then unwrapped it at the end — the exact restyle the
+ * feature exists to avoid. Within a chunk's distance of the end, an unmatched
+ * marker is nearly always a construct still arriving.
+ */
+const TAIL_WINDOW = 80;
+/**
+ * A run that is worth closing optimistically, and its node kind.
+ *
+ * Deliberately no single `*` or `_`. Those are multiplication signs, file names
+ * and `snake_case` far more often than they are emphasis mid-word, and getting it
+ * wrong there restyles ordinary prose. `**`, `__`, `~~` and a backtick are
+ * unambiguous enough to bet on.
+ */
+const OPTIMISTIC_RE = /(\*\*|__|~~|`)([^\s*_~`][^*_~`]*)$/;
+/**
+ * A construct the stream has only begun to type: a trailing marker run, or a link
+ * whose destination has not arrived.
+ *
+ * Anchored, and every alternative bounded. The version this replaced allowed
+ * `\][^)]*` to run to the end of the text, so a CLOSED `[docs]` in the middle of a
+ * sentence matched from the bracket onwards and deleted the rest of the paragraph
+ * — and kept deleting it for the whole stream, because the paragraph stayed the
+ * last block. `See the [docs] for details.` rendered as `See the `.
+ */
+const FRAGMENT_RE = /(?:[*_~`]+|!?\[[^\]\n]*(?:\]\([^)\s]*)?)$/;
+/**
+ * The mid-stream adjustments, applied once to the document's TAIL.
+ *
+ * Everything the streaming mode does beyond parsing an open fence lives here, and
+ * the reason is scope. The tail is the only part of a streamed document that is
+ * still changing, so it is the only part where guessing is defensible; a guess
+ * made inside the inline scanner cannot tell whether it is at the end of the
+ * document or in the middle of a paragraph that finished two chunks ago.
+ *
+ * It descends: the last block may be a quote, or the last item of a list, which is
+ * where most streamed prose actually lives. The version that only looked at a
+ * top-level paragraph left the `**` flicker in place everywhere else while the
+ * documentation claimed otherwise.
+ */
+function applyStreamingTail(blocks) {
+    const last = blocks[blocks.length - 1];
+    if (!last)
+        return blocks;
+    const patched = patchBlock(last);
+    if (patched === last)
+        return blocks;
+    const head = blocks.slice(0, -1);
+    return patched === null ? head : [...head, patched];
+}
+/** `null` to drop the block entirely, the same reference to leave it alone. */
+function patchBlock(block) {
+    switch (block.kind) {
+        case 'paragraph':
+        case 'heading': {
+            // `## ` with nothing after it yet: a node that would render as an empty box.
+            if (block.inlines.length === 0)
+                return null;
+            const inlines = patchInlines(block.inlines);
+            if (inlines === block.inlines)
+                return block;
+            return inlines.length === 0 ? null : { ...block, inlines };
+        }
+        case 'quote': {
+            const children = applyStreamingTail(block.children);
+            if (children === block.children)
+                return block;
+            return children.length === 0 ? null : { ...block, children };
+        }
+        case 'list': {
+            const item = block.items[block.items.length - 1];
+            if (!item)
+                return block;
+            const children = applyStreamingTail(item.children);
+            if (children === item.children)
+                return block;
+            // The item stays even when its content goes: the bullet is already on
+            // screen, and removing it would be a flicker of its own.
+            return { ...block, items: [...block.items.slice(0, -1), { ...item, children }] };
+        }
+        default:
+            return block;
+    }
+}
+function patchInlines(nodes) {
+    const last = nodes[nodes.length - 1];
+    if (!last)
+        return nodes;
+    // The tail may be inside a wrapper — `**bold and [lin` puts it inside the strong.
+    if (last.kind === 'strong' || last.kind === 'em' || last.kind === 'del' || last.kind === 'link') {
+        const children = patchInlines(last.children);
+        if (children === last.children)
+            return nodes;
+        const head = nodes.slice(0, -1);
+        return children.length === 0 ? head : [...head, { ...last, children }];
+    }
+    // A backtick that has only just arrived, already painted as an empty chip.
+    if (last.kind === 'code' && last.value === '')
+        return nodes.slice(0, -1);
+    if (last.kind !== 'text')
+        return nodes;
+    const patched = patchText(last.value);
+    return patched === null ? nodes : [...nodes.slice(0, -1), ...patched];
+}
+/** `null` when the text is not a tail that needs adjusting. */
+function patchText(value) {
+    let text = value;
+    // Repeatedly, because dropping `[lin` from `**bold and [lin` exposes the `**`
+    // behind it, which is then a candidate for the optimistic close below.
+    for (let pass = 0; pass < 3; pass++) {
+        const shorter = text.replace(FRAGMENT_RE, '');
+        if (shorter === text)
+            break;
+        text = shorter;
+    }
+    const opening = OPTIMISTIC_RE.exec(text);
+    if (opening) {
+        const [matched, marker, content] = opening;
+        const at = text.length - matched.length;
+        const before = text.slice(0, at);
+        // `_` may not close against a word character, so mid-word it is not a marker
+        // at all — `snake_case` must not italicise as it arrives.
+        const wordBefore = marker === '__' && at > 0 && /[\p{L}\p{N}]/u.test(text[at - 1]);
+        if (!wordBefore && content.length <= TAIL_WINDOW) {
+            const node = marker === '`'
+                ? { kind: 'code', value: content }
+                : { kind: marker === '~~' ? 'del' : 'strong', children: [{ kind: 'text', value: content }] };
+            return before ? [{ kind: 'text', value: before }, node] : [node];
+        }
+    }
+    if (text === value)
+        return null;
+    return text ? [{ kind: 'text', value: text }] : [];
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * The app's syntax highlighter, or `null` for none.
+ *
+ * Defaults to `null` on purpose: highlighting means a grammar engine, and one of
+ * those in the library's dependency tree would be paid for by every consumer who
+ * renders a paragraph of text. Provide it with `provideWrMarkdownHighlighter()`.
+ */
+const WR_MARKDOWN_HIGHLIGHTER = new InjectionToken('WR_MARKDOWN_HIGHLIGHTER', {
+    factory: () => null,
+});
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * How many highlighted code blocks to remember, per language.
+ *
+ * A requirement of streaming rather than an optimisation: a code block that grows
+ * by a token per chunk asks to be highlighted with a DIFFERENT string every time,
+ * so an unbounded store would hold every intermediate state of every block for the
+ * life of the app — and this service is `providedIn: 'root'`.
+ *
+ * Comfortably larger than any one document, deliberately. A window too small to
+ * hold what is on screen means every pass evicts entries that same pass still
+ * needs and asks for them again — a grammar engine running for ever on a page that
+ * has stopped changing.
+ */
+const CACHE_LIMIT = 256;
+/**
+ * Turns fenced code into coloured spans, once per distinct block.
+ *
+ * **Two rules hold this together, and both were learned by breaking them.**
+ *
+ * `request` never READS a signal that it writes. An earlier version kept the
+ * answers in a signal and rebuilt it on every store, so the component's `effect` —
+ * which calls `request` — depended on the signal `request` wrote, and a document
+ * with more code blocks than the cache could hold looped for ever: evict,
+ * re-request, write, re-dirty. It did not merely spin, it starved the timers that
+ * were supposed to fail the test. The plain `Map` is the source of truth now, and a
+ * single `revision` counter is the only reactive part; nothing that writes reads it
+ * back.
+ *
+ * And `linesFor` is a pure read, safe to call while Angular renders. Asking a
+ * highlighter for a block means writing when the answer lands, and Angular refuses
+ * a signal write during rendering (NG0600) — so the component requests from an
+ * `effect`, which runs after the render, and the template only reads.
+ *
+ * Blocks appear as plain text first and gain colour when the answer arrives. For an
+ * async highlighter that is right rather than a compromise: a grammar engine loads
+ * WASM, and blocking on it would leave the reader with an empty box instead of
+ * their code.
+ */
+class WrMarkdownHighlight {
+    highlighter = inject(WR_MARKDOWN_HIGHLIGHTER);
+    /** Language to code to answer. Insertion order is least-recently-rendered first. */
+    cache = new Map();
+    /** Bumped whenever an answer lands. Read by the template, never by a writer. */
+    revision = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "revision" }] : /* istanbul ignore next */ []));
+    generationSignal = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "generationSignal" }] : /* istanbul ignore next */ []));
+    /**
+     * Bumped ONLY by {@link invalidate}. Read it in the effect that requests, so a
+     * consumer can force a re-ask.
+     *
+     * Separate from `revision` on purpose, and the separation is the whole safety
+     * argument. An effect that requests and also depends on the signal that storing
+     * an answer writes is the shape that looped for ever here once: past the cache
+     * limit, requesting stops being idempotent, so each pass writes, re-dirties the
+     * effect, evicts and requests again. Nothing inside `request` touches this one.
+     */
+    generation = this.generationSignal.asReadonly();
+    /** Spans for one block, or `null` for plain text. Safe to call from a template. */
+    linesFor(code, language) {
+        if (!language)
+            return null;
+        // Establishes the dependency, so a late answer re-renders the block waiting.
+        this.revision();
+        const perLanguage = this.cache.get(language);
+        const entry = perLanguage?.get(code);
+        if (!entry || !perLanguage)
+            return null;
+        // Touched on read, so eviction drops what nobody is rendering rather than what
+        // arrived first. Insertion order had it exactly backwards: mid-stream it
+        // discarded the finished block the reader was looking at and kept the
+        // half-typed intermediates, and the finished block flashed back to plain text.
+        perLanguage.delete(code);
+        perLanguage.set(code, entry);
+        return entry.lines;
+    }
+    /**
+     * Forget every answer and ask again on the next render.
+     *
+     * The cache is keyed on `(language, code)` and nothing else, which is right for
+     * the streaming case it exists for and wrong for one real situation: a
+     * highlighter that returns per-theme colours serves whichever palette was
+     * current when a block was first rendered, for ever. There is no theme
+     * dimension to key on — the library cannot know what a highlighter's answer
+     * depends on — so the honest fix is to let the consumer say when it changed.
+     *
+     * A highlighter that returns theme-agnostic colours (CSS `light-dark()`, a
+     * custom property) needs none of this.
+     *
+     * @example
+     * ```ts
+     * const highlight = inject(WrMarkdownHighlight);
+     * effect(() => {
+     *   theme.current();
+     *   highlight.invalidate();
+     * });
+     * ```
+     */
+    invalidate() {
+        this.cache.clear();
+        this.generationSignal.update(generation => generation + 1);
+        this.revision.update(revision => revision + 1);
+    }
+    /**
+     * Ask for a block to be highlighted. Idempotent, and safe to call for every
+     * block on every change — call it from an `effect`, never from a template.
+     */
+    request(code, language) {
+        // A bare fence has no grammar to pick, so there is nothing to ask for.
+        if (!this.highlighter || !language || !code)
+            return;
+        const perLanguage = this.cache.get(language) ?? new Map();
+        this.cache.set(language, perLanguage);
+        // Presence IS the record of having asked — a separate `asked` set was a second
+        // structure to keep in step with this one, and eviction only pruned one of them.
+        if (perLanguage.has(code))
+            return;
+        const entry = { lines: null };
+        perLanguage.set(code, entry);
+        this.evict(perLanguage);
+        let result;
+        try {
+            result = this.highlighter(code, language);
+        }
+        catch {
+            // A highlighter that throws on an unknown grammar costs the reader colour,
+            // not their code.
+            return;
+        }
+        if (result instanceof Promise) {
+            result.then(lines => this.fill(entry, lines)).catch(() => undefined);
+        }
+        else {
+            this.fill(entry, result);
+        }
+    }
+    /**
+     * Fill in an answer and let the view know.
+     *
+     * Writes through the entry OBJECT rather than looking its key up again. The entry
+     * may have been evicted while the promise was in flight, in which case this
+     * writes to something nothing holds — which is the intended outcome. The version
+     * that re-inserted by key put entries back behind eviction's back, and the cache
+     * grew without a ceiling for exactly the async highlighter its limit exists for.
+     */
+    fill(entry, lines) {
+        if (!lines)
+            return;
+        entry.lines = lines;
+        this.revision.update(revision => revision + 1);
+    }
+    /** `Map` iterates in insertion order, and `linesFor` re-inserts on read. */
+    evict(perLanguage) {
+        while (perLanguage.size > CACHE_LIMIT) {
+            const oldest = perLanguage.keys().next();
+            if (oldest.done)
+                return;
+            perLanguage.delete(oldest.value);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.1", ngImport: i0, type: WrMarkdownHighlight, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.1", ngImport: i0, type: WrMarkdownHighlight, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.1", ngImport: i0, type: WrMarkdownHighlight, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/** How long the copy button stays in its "copied" state. */
+const COPIED_FEEDBACK_MS = 2000;
+/** Code blocks anywhere in the tree — a quote or a list item holds blocks too. */
+function collectCode(blocks) {
+    const found = [];
+    for (const block of blocks) {
+        if (block.kind === 'code')
+            found.push({ code: block.code, language: block.language });
+        if (block.kind === 'quote')
+            found.push(...collectCode(block.children));
+        if (block.kind === 'list')
+            for (const item of block.items)
+                found.push(...collectCode(item.children));
+    }
+    return found;
+}
+/**
+ * Renders markdown — as DOM, not as HTML.
+ *
+ * Built for streamed model output, and useful for any markdown an app does not
+ * write itself: comments, release notes, a README. `[streaming]` makes a partial
+ * document render like a whole one (see {@link parseMarkdown}); without it the
+ * component is an ordinary renderer.
+ *
+ * **Raw HTML in the source is escaped, never rendered.** That is a deliberate
+ * limit rather than an unfinished feature: the input is untrusted by
+ * construction, `[innerHTML]` is how every comparable renderer takes it, and one
+ * `<img onerror>` is the whole cost of being wrong. Nothing here is parsed as
+ * HTML at any point — every text node is a text node and every `href` goes
+ * through Angular's URL sanitizer on top of this component's own scheme check.
+ *
+ * @example
+ * ```html
+ * <wr-markdown [value]="answer()" [streaming]="pending()" copyable />
+ * ```
+ *
+ * @see https://ngwr.dev/reference/components/markdown
+ */
+class WrMarkdown {
+    highlight = inject(WrMarkdownHighlight);
+    destroyRef = inject(DestroyRef);
+    /** The markdown source. */
+    value = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+    /**
+     * The source is a prefix of a longer document.
+     *
+     * Turns on partial-safe parsing — an open fence renders as code, a half-typed
+     * `**bold` renders as bold rather than as asterisks — and marks the host with
+     * `.wr-markdown--streaming`, which paints a caret after the last block.
+     *
+     * @default false
+     */
+    streaming = input(false, { ...(ngDevMode ? { debugName: "streaming" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    /**
+     * Show a copy button on finished code blocks.
+     *
+     * Falls back to `markdown.copyable` from `provideWrConfig()`, then `false`.
+     * Only CLOSED blocks get one: mid-stream the code is not all there, and a
+     * button that copies half a snippet is worse than no button.
+     */
+    copyable = input(null, { ...(ngDevMode ? { debugName: "copyable" } : /* istanbul ignore next */ {}), 
+        // `null` survives, because it is what "the template said nothing" means to
+        // `useConfigValue` — but a bare `copyable` attribute has to reach `true`, and
+        // without a transform it arrives as `''` and does not compile under
+        // `strictTemplates`. The component's own JSDoc example was the proof.
+        transform: value => (value == null ? null : coerceBooleanProperty(value)) });
+    /**
+     * Where links open. `_blank` also sets `rel="noopener noreferrer"`, which is
+     * not optional — a target without it hands the opener to a page whose URL came
+     * from the document being rendered.
+     *
+     * Falls back to `markdown.linkTarget` from `provideWrConfig()`, then no target.
+     */
+    linkTarget = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "linkTarget" }] : /* istanbul ignore next */ []));
+    /**
+     * Put a slugged `id` on every heading, so the document can be linked into.
+     *
+     * @default true
+     */
+    headingIds = input(true, { ...(ngDevMode ? { debugName: "headingIds" } : /* istanbul ignore next */ {}), transform: coerceBooleanProperty });
+    /**
+     * Namespace for the generated heading ids, and for the in-document `#fragment`
+     * links that point at them.
+     *
+     * Defaults to `'user-content-'`, which is what GitHub emits for untrusted
+     * markdown, and for the same reason: without a namespace a document that
+     * happens to contain `# Search` renders `id="search"` and steals it from the
+     * page around it. That is not cosmetic — a `<label for="search">` silently
+     * stops labelling its input, and `getElementById` starts answering with a
+     * heading. Anchors written INSIDE the document keep working, because a bare
+     * `#fragment` href gets the same prefix.
+     *
+     * Set it to `''` for a document you author yourself and want clean anchors for.
+     */
+    headingIdPrefix = input('user-content-', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "headingIdPrefix" }] : /* istanbul ignore next */ []));
+    /** Accessible name of the copy button. Falls back to `markdown.copy`, then `'Copy code'`. */
+    copyLabel = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "copyLabel" }] : /* istanbul ignore next */ []));
+    /** Announced after a successful copy. Falls back to `markdown.copied`, then `'Copied'`. */
+    copiedLabel = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "copiedLabel" }] : /* istanbul ignore next */ []));
+    /** Read out for a checked task item. Falls back to `markdown.taskDone`, then `'Done:'`. */
+    taskDoneLabel = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "taskDoneLabel" }] : /* istanbul ignore next */ []));
+    /** Read out for an unchecked task item. Falls back to `markdown.taskTodo`, then `'To do:'`. */
+    taskTodoLabel = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "taskTodoLabel" }] : /* istanbul ignore next */ []));
+    resolvedCopyable = useConfigValue(this.copyable, config => config.markdown?.copyable, false);
+    resolvedLinkTarget = useConfigValue(this.linkTarget, config => config.markdown?.linkTarget, null);
+    resolvedCopyLabel = useI18nText(this.copyLabel, 'markdown.copy', 'Copy code');
+    resolvedCopiedLabel = useI18nText(this.copiedLabel, 'markdown.copied', 'Copied');
+    resolvedTaskDoneLabel = useI18nText(this.taskDoneLabel, 'markdown.taskDone', 'Done:');
+    resolvedTaskTodoLabel = useI18nText(this.taskTodoLabel, 'markdown.taskTodo', 'To do:');
+    /**
+     * The parsed document, re-derived whenever the source changes.
+     *
+     * The WHOLE buffer, on every chunk — so a streamed answer costs O(n²) over the
+     * stream. That is a deliberate trade rather than an oversight: freezing the
+     * blocks before the last blank line would halve it, but a blank line is not a
+     * safe boundary in markdown (a list continues across one), and a wrong boundary
+     * corrupts the document rather than slowing it down. The constant is small —
+     * 300 KB of prose parses in ~120 ms — and `@for`'s `track $index` keeps the
+     * DOM cost proportional to what actually changed.
+     */
+    blocks = computed(() => parseMarkdown(this.value(), { streaming: this.streaming() }), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "blocks" }] : /* istanbul ignore next */ []));
+    /** `rel` is bound, not hard-coded, so a same-tab link does not carry a pointless one. */
+    linkRel = computed(() => (this.resolvedLinkTarget() === '_blank' ? 'noopener noreferrer' : null), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "linkRel" }] : /* istanbul ignore next */ []));
+    /**
+     * Which code block last got copied, held by IDENTITY.
+     *
+     * Keyed on the code string, two blocks containing the same snippet both lit up
+     * — and a document that shows the same one-liner twice is ordinary. Block nodes
+     * are recreated whenever the source changes, so the confirmation also clears
+     * itself on the next chunk, which is the right lifetime for it.
+     */
+    copiedBlock = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "copiedBlock" }] : /* istanbul ignore next */ []));
+    copiedTimer = null;
+    constructor() {
+        // Requested here rather than from the template: asking the highlighter means
+        // writing a signal when the answer lands, and Angular refuses a signal write
+        // during rendering (NG0600). An effect runs after it.
+        effect(() => {
+            // `generation` is what makes `WrMarkdownHighlight.invalidate()` reach the
+            // blocks already on screen. It is deliberately NOT the signal that storing
+            // an answer bumps — depending on that one from here is the loop.
+            this.highlight.generation();
+            for (const block of this.codeBlocks())
+                this.highlight.request(block.code, block.language);
+        });
+        this.destroyRef.onDestroy(() => {
+            if (this.copiedTimer !== null)
+                clearTimeout(this.copiedTimer);
+        });
+    }
+    /**
+     * A newline as data rather than as template text.
+     *
+     * The lines of a highlighted block are separate elements, and what separates
+     * them on screen — and in a copy — is a real `\n` inside the `<pre>`. Angular
+     * strips whitespace-only text nodes from templates, so the character cannot be
+     * typed there; an interpolation of it survives.
+     */
+    newline = String.fromCharCode(10);
+    /** Every code block in the document, nested ones included. */
+    codeBlocks = computed(() => collectCode(this.blocks()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "codeBlocks" }] : /* istanbul ignore next */ []));
+    /** Spans for a code block, or `null` to render it as plain text. */
+    linesOf(code, language) {
+        return this.highlight.linesFor(code, language);
+    }
+    isCopied(block) {
+        return this.copiedBlock() === block;
+    }
+    onCopied(block) {
+        this.copiedBlock.set(block);
+        if (this.copiedTimer !== null)
+            clearTimeout(this.copiedTimer);
+        this.copiedTimer = setTimeout(() => {
+            this.copiedBlock.set(null);
+            this.copiedTimer = null;
+        }, COPIED_FEEDBACK_MS);
+    }
+    /** A heading's id, namespaced, or `null` when there is nothing to link to. */
+    idOf(id) {
+        if (!this.headingIds() || !id)
+            return null;
+        return `${this.headingIdPrefix()}${id}`;
+    }
+    /**
+     * A link's destination, with a bare fragment pointed at the namespaced id.
+     *
+     * Otherwise prefixing the headings would quietly break every `[see](#section)`
+     * the document writes about itself.
+     */
+    hrefOf(href) {
+        const prefix = this.headingIdPrefix();
+        if (!prefix || !this.headingIds() || !href.startsWith('#') || href.length < 2)
+            return href;
+        return `#${prefix}${href.slice(1)}`;
+    }
+    /**
+     * Casts for the recursive templates, and the reason they exist.
+     *
+     * Block content nests — a quote holds blocks, a list item holds blocks — so the
+     * template recurses through `ngTemplateOutlet` into itself. That is the one
+     * recursion shape which adds NO elements to the DOM; a recursive component
+     * would put a host element between `<ul>` and its `<li>`, which is invalid
+     * markup and breaks the list's accessibility tree. The cost is that
+     * `ngTemplateOutlet` context arrives as `any`, and `@switch` cannot narrow
+     * `any`. Casting it back at the top of each template restores full
+     * `strictTemplates` checking inside the loop, where the work happens.
+     */
+    asBlocks(value) {
+        return value;
+    }
+    asInlines(value) {
+        return value;
+    }
+    asItems(value) {
+        return value;
+    }
+    asCells(value) {
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.1", ngImport: i0, type: WrMarkdown, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.1", type: WrMarkdown, isStandalone: true, selector: "wr-markdown", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, streaming: { classPropertyName: "streaming", publicName: "streaming", isSignal: true, isRequired: false, transformFunction: null }, copyable: { classPropertyName: "copyable", publicName: "copyable", isSignal: true, isRequired: false, transformFunction: null }, linkTarget: { classPropertyName: "linkTarget", publicName: "linkTarget", isSignal: true, isRequired: false, transformFunction: null }, headingIds: { classPropertyName: "headingIds", publicName: "headingIds", isSignal: true, isRequired: false, transformFunction: null }, headingIdPrefix: { classPropertyName: "headingIdPrefix", publicName: "headingIdPrefix", isSignal: true, isRequired: false, transformFunction: null }, copyLabel: { classPropertyName: "copyLabel", publicName: "copyLabel", isSignal: true, isRequired: false, transformFunction: null }, copiedLabel: { classPropertyName: "copiedLabel", publicName: "copiedLabel", isSignal: true, isRequired: false, transformFunction: null }, taskDoneLabel: { classPropertyName: "taskDoneLabel", publicName: "taskDoneLabel", isSignal: true, isRequired: false, transformFunction: null }, taskTodoLabel: { classPropertyName: "taskTodoLabel", publicName: "taskTodoLabel", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.wr-markdown--streaming": "streaming()" }, classAttribute: "wr-markdown" }, ngImport: i0, template: "<!--\n  Recursion runs through `ngTemplateOutlet` into these templates rather than\n  through a child component, so the rendered DOM is exactly the document \u2014 no\n  wrapper element between a `<ul>` and its `<li>`. See `asBlocks` for the whole\n  reasoning.\n-->\n<ng-template #inlineList let-raw>\n  @let nodes = asInlines(raw);\n\n  @for (node of nodes; track $index) {\n    @switch (node.kind) {\n      @case ('text') {\n        <!-- Wrapped, and not for tidiness: a bare interpolation on its own line is\n             ONE text node that includes the indentation around it, so `a **b** c`\n             rendered with a space inside every `<strong>`. Inside an element the\n             whitespace becomes separate whitespace-only nodes, which Angular\n             removes, and `<ng-container>` itself renders nothing. Prettier\n             reformats the bare form back, so this also has to survive `--fix`. -->\n        <ng-container>{{ node.value }}</ng-container>\n      }\n      @case ('code') {\n        <!-- `dir=\"ltr\"` because code is not prose: under RTL the browser\n             reorders `foo();` to `;foo()`. -->\n        <code class=\"wr-markdown__code-inline\" dir=\"ltr\">{{ node.value }}</code>\n      }\n      @case ('strong') {\n        <strong class=\"wr-markdown__strong\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></strong>\n      }\n      @case ('em') {\n        <em class=\"wr-markdown__em\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></em>\n      }\n      @case ('del') {\n        <del class=\"wr-markdown__del\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></del>\n      }\n      @case ('link') {\n        <a\n          class=\"wr-markdown__link\"\n          [href]=\"hrefOf(node.href)\"\n          [attr.title]=\"node.title\"\n          [attr.target]=\"resolvedLinkTarget()\"\n          [attr.rel]=\"linkRel()\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></a>\n      }\n      @case ('image') {\n        <img\n          class=\"wr-markdown__image\"\n          [src]=\"node.src\"\n          [alt]=\"node.alt\"\n          [attr.title]=\"node.title\"\n          loading=\"lazy\"\n          decoding=\"async\"\n        />\n      }\n      @case ('break') {\n        <br />\n      }\n    }\n  }\n</ng-template>\n\n<ng-template #itemList let-raw let-tight=\"tight\">\n  @let items = asItems(raw);\n\n  @for (item of items; track $index) {\n    <li class=\"wr-markdown__item\" [class.wr-markdown__item--task]=\"item.checked !== null\">\n      @if (item.checked !== null) {\n        <!-- Presentational, with the state as text beside it: a real\n             `<input type=\"checkbox\">` here would be an unlabelled form control,\n             which is a serious axe violation, and making it operable would\n             promise an interaction a renderer cannot honour. -->\n        <span class=\"wr-markdown__task\" [class.wr-markdown__task--checked]=\"item.checked\" aria-hidden=\"true\"></span>\n        <span class=\"wr-markdown__sr-only\">{{ item.checked ? resolvedTaskDoneLabel() : resolvedTaskTodoLabel() }}</span>\n      }\n      <ng-container\n        [ngTemplateOutlet]=\"blockList\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.children, tight: tight }\"\n      />\n    </li>\n  }\n</ng-template>\n\n<ng-template #blockList let-raw let-tight=\"tight\">\n  @let list = asBlocks(raw);\n\n  @for (block of list; track $index) {\n    @switch (block.kind) {\n      @case ('paragraph') {\n        <!-- A tight list drops the `<p>`, which is what CommonMark specifies and\n             what keeps a one-line list from being double-spaced. -->\n        @if (tight) {\n          <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n        } @else {\n          <p class=\"wr-markdown__paragraph\">\n            <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n          </p>\n        }\n      }\n      @case ('heading') {\n        @switch (block.level) {\n          @case (1) {\n            <h1 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h1>\n          }\n          @case (2) {\n            <h2 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h2>\n          }\n          @case (3) {\n            <h3 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h3>\n          }\n          @case (4) {\n            <h4 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h4>\n          }\n          @case (5) {\n            <h5 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h5>\n          }\n          @default {\n            <h6 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h6>\n          }\n        }\n      }\n      @case ('code') {\n        @let highlighted = linesOf(block.code, block.language);\n\n        <div class=\"wr-markdown__code-block\">\n          <pre\n            class=\"wr-markdown__pre\"\n            dir=\"ltr\"\n            tabindex=\"0\"\n          ><code class=\"wr-markdown__code\" [attr.data-language]=\"block.language\">@if (highlighted) {@for (row of highlighted; track $index) {<span class=\"wr-markdown__line\">@for (span of row; track $index) {<span\n            [style.color]=\"span.color\"\n            [style.font-style]=\"span.fontStyle === 'italic' ? 'italic' : null\"\n            [style.font-weight]=\"span.fontStyle === 'bold' ? 'bold' : null\"\n            [style.text-decoration]=\"span.fontStyle === 'underline' ? 'underline' : null\"\n          >{{ span.text }}</span>}</span>@if (!$last) {{{ newline }}}}} @else {{{ block.code }}}</code></pre>\n\n          @if (resolvedCopyable() && block.closed) {\n            <button\n              type=\"button\"\n              class=\"wr-markdown__copy\"\n              [wrCopyToClipboard]=\"block.code\"\n              [attr.aria-label]=\"isCopied(block) ? resolvedCopiedLabel() : resolvedCopyLabel()\"\n              (copied)=\"onCopied(block)\"\n            >\n              <svg\n                class=\"wr-markdown__copy-icon\"\n                xmlns=\"http://www.w3.org/2000/svg\"\n                viewBox=\"0 0 24 24\"\n                fill=\"none\"\n                stroke=\"currentColor\"\n                stroke-width=\"2\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n                aria-hidden=\"true\"\n              >\n                @if (isCopied(block)) {\n                  <path d=\"M20 6 9 17l-5-5\" />\n                } @else {\n                  <rect width=\"14\" height=\"14\" x=\"8\" y=\"8\" rx=\"2\" ry=\"2\" />\n                  <path d=\"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2\" />\n                }\n              </svg>\n            </button>\n          }\n        </div>\n      }\n      @case ('quote') {\n        <blockquote class=\"wr-markdown__quote\">\n          <ng-container\n            [ngTemplateOutlet]=\"blockList\"\n            [ngTemplateOutletContext]=\"{ $implicit: block.children, tight: false }\"\n          />\n        </blockquote>\n      }\n      @case ('list') {\n        @if (block.ordered) {\n          <ol\n            class=\"wr-markdown__list wr-markdown__list--ordered\"\n            [attr.start]=\"block.start === 1 ? null : block.start\"\n          >\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ol>\n        } @else {\n          <ul class=\"wr-markdown__list\">\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ul>\n        }\n      }\n      @case ('table') {\n        <!-- Its own scroller: a wide table must not push the page sideways, which\n             is also what keeps the RTL layout gate quiet about it. -->\n        <div class=\"wr-markdown__table-scroll\" tabindex=\"0\">\n          <table class=\"wr-markdown__table\">\n            <thead>\n              <tr>\n                @for (cell of block.head; track column; let column = $index) {\n                  <th class=\"wr-markdown__th\" scope=\"col\" [style.text-align]=\"block.align[column]\">\n                    <ng-container\n                      [ngTemplateOutlet]=\"inlineList\"\n                      [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                    />\n                  </th>\n                }\n              </tr>\n            </thead>\n            <tbody>\n              @for (row of block.rows; track $index) {\n                <tr>\n                  @for (cell of asCells(row); track column; let column = $index) {\n                    <td class=\"wr-markdown__td\" [style.text-align]=\"block.align[column]\">\n                      <ng-container\n                        [ngTemplateOutlet]=\"inlineList\"\n                        [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                      />\n                    </td>\n                  }\n                </tr>\n              }\n            </tbody>\n          </table>\n        </div>\n      }\n      @case ('rule') {\n        <hr class=\"wr-markdown__rule\" />\n      }\n    }\n  }\n</ng-template>\n\n<ng-container [ngTemplateOutlet]=\"blockList\" [ngTemplateOutletContext]=\"{ $implicit: blocks(), tight: false }\" />\n", dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: WrCopyToClipboard, selector: "[wrCopyToClipboard]", inputs: ["wrCopyToClipboard"], outputs: ["copied", "copyFailed"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.1", ngImport: i0, type: WrMarkdown, decorators: [{
+            type: Component,
+            args: [{ selector: 'wr-markdown', imports: [NgTemplateOutlet, WrCopyToClipboard], encapsulation: ViewEncapsulation.None, host: {
+                        class: 'wr-markdown',
+                        '[class.wr-markdown--streaming]': 'streaming()',
+                    }, template: "<!--\n  Recursion runs through `ngTemplateOutlet` into these templates rather than\n  through a child component, so the rendered DOM is exactly the document \u2014 no\n  wrapper element between a `<ul>` and its `<li>`. See `asBlocks` for the whole\n  reasoning.\n-->\n<ng-template #inlineList let-raw>\n  @let nodes = asInlines(raw);\n\n  @for (node of nodes; track $index) {\n    @switch (node.kind) {\n      @case ('text') {\n        <!-- Wrapped, and not for tidiness: a bare interpolation on its own line is\n             ONE text node that includes the indentation around it, so `a **b** c`\n             rendered with a space inside every `<strong>`. Inside an element the\n             whitespace becomes separate whitespace-only nodes, which Angular\n             removes, and `<ng-container>` itself renders nothing. Prettier\n             reformats the bare form back, so this also has to survive `--fix`. -->\n        <ng-container>{{ node.value }}</ng-container>\n      }\n      @case ('code') {\n        <!-- `dir=\"ltr\"` because code is not prose: under RTL the browser\n             reorders `foo();` to `;foo()`. -->\n        <code class=\"wr-markdown__code-inline\" dir=\"ltr\">{{ node.value }}</code>\n      }\n      @case ('strong') {\n        <strong class=\"wr-markdown__strong\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></strong>\n      }\n      @case ('em') {\n        <em class=\"wr-markdown__em\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></em>\n      }\n      @case ('del') {\n        <del class=\"wr-markdown__del\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></del>\n      }\n      @case ('link') {\n        <a\n          class=\"wr-markdown__link\"\n          [href]=\"hrefOf(node.href)\"\n          [attr.title]=\"node.title\"\n          [attr.target]=\"resolvedLinkTarget()\"\n          [attr.rel]=\"linkRel()\"\n          ><ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: node.children }\"\n        /></a>\n      }\n      @case ('image') {\n        <img\n          class=\"wr-markdown__image\"\n          [src]=\"node.src\"\n          [alt]=\"node.alt\"\n          [attr.title]=\"node.title\"\n          loading=\"lazy\"\n          decoding=\"async\"\n        />\n      }\n      @case ('break') {\n        <br />\n      }\n    }\n  }\n</ng-template>\n\n<ng-template #itemList let-raw let-tight=\"tight\">\n  @let items = asItems(raw);\n\n  @for (item of items; track $index) {\n    <li class=\"wr-markdown__item\" [class.wr-markdown__item--task]=\"item.checked !== null\">\n      @if (item.checked !== null) {\n        <!-- Presentational, with the state as text beside it: a real\n             `<input type=\"checkbox\">` here would be an unlabelled form control,\n             which is a serious axe violation, and making it operable would\n             promise an interaction a renderer cannot honour. -->\n        <span class=\"wr-markdown__task\" [class.wr-markdown__task--checked]=\"item.checked\" aria-hidden=\"true\"></span>\n        <span class=\"wr-markdown__sr-only\">{{ item.checked ? resolvedTaskDoneLabel() : resolvedTaskTodoLabel() }}</span>\n      }\n      <ng-container\n        [ngTemplateOutlet]=\"blockList\"\n        [ngTemplateOutletContext]=\"{ $implicit: item.children, tight: tight }\"\n      />\n    </li>\n  }\n</ng-template>\n\n<ng-template #blockList let-raw let-tight=\"tight\">\n  @let list = asBlocks(raw);\n\n  @for (block of list; track $index) {\n    @switch (block.kind) {\n      @case ('paragraph') {\n        <!-- A tight list drops the `<p>`, which is what CommonMark specifies and\n             what keeps a one-line list from being double-spaced. -->\n        @if (tight) {\n          <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n        } @else {\n          <p class=\"wr-markdown__paragraph\">\n            <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n          </p>\n        }\n      }\n      @case ('heading') {\n        @switch (block.level) {\n          @case (1) {\n            <h1 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h1>\n          }\n          @case (2) {\n            <h2 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h2>\n          }\n          @case (3) {\n            <h3 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h3>\n          }\n          @case (4) {\n            <h4 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h4>\n          }\n          @case (5) {\n            <h5 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h5>\n          }\n          @default {\n            <h6 class=\"wr-markdown__heading\" [attr.id]=\"idOf(block.id)\">\n              <ng-container [ngTemplateOutlet]=\"inlineList\" [ngTemplateOutletContext]=\"{ $implicit: block.inlines }\" />\n            </h6>\n          }\n        }\n      }\n      @case ('code') {\n        @let highlighted = linesOf(block.code, block.language);\n\n        <div class=\"wr-markdown__code-block\">\n          <pre\n            class=\"wr-markdown__pre\"\n            dir=\"ltr\"\n            tabindex=\"0\"\n          ><code class=\"wr-markdown__code\" [attr.data-language]=\"block.language\">@if (highlighted) {@for (row of highlighted; track $index) {<span class=\"wr-markdown__line\">@for (span of row; track $index) {<span\n            [style.color]=\"span.color\"\n            [style.font-style]=\"span.fontStyle === 'italic' ? 'italic' : null\"\n            [style.font-weight]=\"span.fontStyle === 'bold' ? 'bold' : null\"\n            [style.text-decoration]=\"span.fontStyle === 'underline' ? 'underline' : null\"\n          >{{ span.text }}</span>}</span>@if (!$last) {{{ newline }}}}} @else {{{ block.code }}}</code></pre>\n\n          @if (resolvedCopyable() && block.closed) {\n            <button\n              type=\"button\"\n              class=\"wr-markdown__copy\"\n              [wrCopyToClipboard]=\"block.code\"\n              [attr.aria-label]=\"isCopied(block) ? resolvedCopiedLabel() : resolvedCopyLabel()\"\n              (copied)=\"onCopied(block)\"\n            >\n              <svg\n                class=\"wr-markdown__copy-icon\"\n                xmlns=\"http://www.w3.org/2000/svg\"\n                viewBox=\"0 0 24 24\"\n                fill=\"none\"\n                stroke=\"currentColor\"\n                stroke-width=\"2\"\n                stroke-linecap=\"round\"\n                stroke-linejoin=\"round\"\n                aria-hidden=\"true\"\n              >\n                @if (isCopied(block)) {\n                  <path d=\"M20 6 9 17l-5-5\" />\n                } @else {\n                  <rect width=\"14\" height=\"14\" x=\"8\" y=\"8\" rx=\"2\" ry=\"2\" />\n                  <path d=\"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2\" />\n                }\n              </svg>\n            </button>\n          }\n        </div>\n      }\n      @case ('quote') {\n        <blockquote class=\"wr-markdown__quote\">\n          <ng-container\n            [ngTemplateOutlet]=\"blockList\"\n            [ngTemplateOutletContext]=\"{ $implicit: block.children, tight: false }\"\n          />\n        </blockquote>\n      }\n      @case ('list') {\n        @if (block.ordered) {\n          <ol\n            class=\"wr-markdown__list wr-markdown__list--ordered\"\n            [attr.start]=\"block.start === 1 ? null : block.start\"\n          >\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ol>\n        } @else {\n          <ul class=\"wr-markdown__list\">\n            <ng-container\n              [ngTemplateOutlet]=\"itemList\"\n              [ngTemplateOutletContext]=\"{ $implicit: block.items, tight: block.tight }\"\n            />\n          </ul>\n        }\n      }\n      @case ('table') {\n        <!-- Its own scroller: a wide table must not push the page sideways, which\n             is also what keeps the RTL layout gate quiet about it. -->\n        <div class=\"wr-markdown__table-scroll\" tabindex=\"0\">\n          <table class=\"wr-markdown__table\">\n            <thead>\n              <tr>\n                @for (cell of block.head; track column; let column = $index) {\n                  <th class=\"wr-markdown__th\" scope=\"col\" [style.text-align]=\"block.align[column]\">\n                    <ng-container\n                      [ngTemplateOutlet]=\"inlineList\"\n                      [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                    />\n                  </th>\n                }\n              </tr>\n            </thead>\n            <tbody>\n              @for (row of block.rows; track $index) {\n                <tr>\n                  @for (cell of asCells(row); track column; let column = $index) {\n                    <td class=\"wr-markdown__td\" [style.text-align]=\"block.align[column]\">\n                      <ng-container\n                        [ngTemplateOutlet]=\"inlineList\"\n                        [ngTemplateOutletContext]=\"{ $implicit: cell.inlines }\"\n                      />\n                    </td>\n                  }\n                </tr>\n              }\n            </tbody>\n          </table>\n        </div>\n      }\n      @case ('rule') {\n        <hr class=\"wr-markdown__rule\" />\n      }\n    }\n  }\n</ng-template>\n\n<ng-container [ngTemplateOutlet]=\"blockList\" [ngTemplateOutletContext]=\"{ $implicit: blocks(), tight: false }\" />\n" }]
+        }], ctorParameters: () => [], propDecorators: { value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }], streaming: [{ type: i0.Input, args: [{ isSignal: true, alias: "streaming", required: false }] }], copyable: [{ type: i0.Input, args: [{ isSignal: true, alias: "copyable", required: false }] }], linkTarget: [{ type: i0.Input, args: [{ isSignal: true, alias: "linkTarget", required: false }] }], headingIds: [{ type: i0.Input, args: [{ isSignal: true, alias: "headingIds", required: false }] }], headingIdPrefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "headingIdPrefix", required: false }] }], copyLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "copyLabel", required: false }] }], copiedLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "copiedLabel", required: false }] }], taskDoneLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "taskDoneLabel", required: false }] }], taskTodoLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "taskTodoLabel", required: false }] }] } });
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Give every `<wr-markdown>` in the app a syntax highlighter.
+ *
+ * The highlighter returns coloured SPANS, not HTML — see
+ * {@link WrMarkdownHighlighter} for why that signature is the one worth having.
+ * It may be async, and it may return `null` for languages it does not know; both
+ * render the block as plain text, which is also what server-side rendering
+ * produces, since a highlighter that resolves after prerender has already
+ * finished cannot contribute to the HTML.
+ *
+ * Pass `{ useFactory }` when the adapter needs to inject something. A highlighter
+ * is itself a function, so the factory cannot be detected by shape — hence the
+ * wrapper object rather than an overload that would guess.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideWrMarkdownHighlighter(shikiSpans),
+ *
+ *     // Or, when the adapter has dependencies of its own:
+ *     provideWrMarkdownHighlighter({
+ *       useFactory: () => {
+ *         const isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+ *         return (code, language) => (isBrowser ? shikiSpans(code, language) : null);
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+function provideWrMarkdownHighlighter(highlighter) {
+    if (typeof highlighter === 'function') {
+        return makeEnvironmentProviders([{ provide: WR_MARKDOWN_HIGHLIGHTER, useValue: highlighter }]);
+    }
+    return makeEnvironmentProviders([{ provide: WR_MARKDOWN_HIGHLIGHTER, useFactory: highlighter.useFactory }]);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WR_MARKDOWN_HIGHLIGHTER, WrMarkdown, WrMarkdownHighlight, parseInlines, parseMarkdown, plainText, provideWrMarkdownHighlighter, safeMarkdownUrl };
+//# sourceMappingURL=ngwr-markdown.mjs.map