ngwr 10.2.0 → 11.0.0

package/types/ngwr-markdown.d.ts

@@ -0,0 +1,534 @@
+import * as _angular_core from '@angular/core';
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+/**
+ * @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
+ */
+/** One coloured run inside a highlighted line of code. */
+interface WrHighlightSpan {
+    readonly text: string;
+    /** Any CSS colour. Omitted spans inherit the code block's own colour. */
+    readonly color?: string;
+    readonly fontStyle?: 'italic' | 'bold' | 'underline';
+}
+/** One line of highlighted code, left to right. */
+type WrHighlightLine = readonly WrHighlightSpan[];
+/**
+ * Turns a fenced code block into coloured spans.
+ *
+ * **Spans, not an HTML string** — and that is the whole point of this signature.
+ * Every other Angular markdown renderer takes highlighted HTML and hands it to
+ * `[innerHTML]`, which needs `bypassSecurityTrustHtml` (Angular's own sanitizer
+ * strips the inline `style` attributes highlighting is made of, so the trust
+ * cannot be skipped). That puts a `dangerouslySetInnerHTML`-shaped hole in the
+ * one component whose entire input is untrusted text. Spans close it: `wr-markdown`
+ * renders each one as a real element with a bound `[style.color]`, so nothing in
+ * the pipeline is ever parsed as HTML and the library keeps its
+ * `unsafe-inline`-free CSP story.
+ *
+ * Return `null` for a language you do not handle — the block then renders as
+ * plain text, which is also what happens before an async highlighter resolves.
+ *
+ * @example
+ * ```ts
+ * // Shiki, whose `codeToTokens` already returns this shape.
+ * provideWrMarkdownHighlighter(async (code, language) => {
+ *   const shiki = await getHighlighter();
+ *   if (!language || !shiki.getLoadedLanguages().includes(language)) return null;
+ *   const { tokens } = shiki.codeToTokens(code, { lang: language, theme: 'github-dark' });
+ *   return tokens.map(line => line.map(t => ({ text: t.content, color: t.color })));
+ * });
+ * ```
+ */
+type WrMarkdownHighlighter = (code: string, language: string | null) => readonly WrHighlightLine[] | null | Promise<readonly WrHighlightLine[] | 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
+ */
+/** Column alignment of a GFM table, `null` when the delimiter row said nothing. */
+type WrMarkdownAlign = 'start' | 'center' | 'end' | null;
+/** A run of inline content — the leaves of a paragraph, heading or table cell. */
+type WrMarkdownInline = {
+    readonly kind: 'text';
+    readonly value: string;
+} | {
+    readonly kind: 'code';
+    readonly value: string;
+} | {
+    readonly kind: 'strong';
+    readonly children: readonly WrMarkdownInline[];
+} | {
+    readonly kind: 'em';
+    readonly children: readonly WrMarkdownInline[];
+} | {
+    readonly kind: 'del';
+    readonly children: readonly WrMarkdownInline[];
+} | {
+    readonly kind: 'link';
+    readonly href: string;
+    readonly title: string | null;
+    readonly children: readonly WrMarkdownInline[];
+} | {
+    readonly kind: 'image';
+    readonly src: string;
+    readonly alt: string;
+    readonly title: string | null;
+} | {
+    readonly kind: 'break';
+};
+/** One `<li>`, including its task-list checkbox state. */
+interface WrMarkdownListItem {
+    readonly children: readonly WrMarkdownBlock[];
+    /** `true` / `false` for `- [x]` / `- [ ]`, `null` for an ordinary item. */
+    readonly checked: boolean | null;
+}
+/** One table cell. */
+interface WrMarkdownCell {
+    readonly inlines: readonly WrMarkdownInline[];
+}
+/** A block-level node. `kind` discriminates the union. */
+type WrMarkdownBlock = {
+    readonly kind: 'heading';
+    readonly level: 1 | 2 | 3 | 4 | 5 | 6;
+    readonly inlines: readonly WrMarkdownInline[];
+    /** Slug derived from the text, for anchoring. Empty when the heading has no text. */
+    readonly id: string;
+} | {
+    readonly kind: 'paragraph';
+    readonly inlines: readonly WrMarkdownInline[];
+} | {
+    readonly kind: 'code';
+    /** First word of the info string, lowercased. `null` for a bare fence. */
+    readonly language: string | null;
+    readonly code: string;
+    /**
+     * `false` while the closing fence has not arrived. Mid-stream that is the
+     * normal state, and it is what lets a consumer hold back a "copy" affordance
+     * until the block is whole.
+     */
+    readonly closed: boolean;
+} | {
+    readonly kind: 'quote';
+    readonly children: readonly WrMarkdownBlock[];
+} | {
+    readonly kind: 'list';
+    readonly ordered: boolean;
+    /** First number of an ordered list; `1` for bullets. */
+    readonly start: number;
+    /** A tight list renders its items' paragraphs bare, as CommonMark specifies. */
+    readonly tight: boolean;
+    readonly items: readonly WrMarkdownListItem[];
+} | {
+    readonly kind: 'table';
+    readonly head: readonly WrMarkdownCell[];
+    readonly rows: readonly (readonly WrMarkdownCell[])[];
+    readonly align: readonly WrMarkdownAlign[];
+} | {
+    readonly kind: 'rule';
+};
+/** Options for {@link parseMarkdown}. */
+interface WrMarkdownParseOptions {
+    /**
+     * Treat the source as a prefix of a longer document.
+     *
+     * An unterminated fence still produces a code block (so code appears as it
+     * arrives rather than after the closing fence), and a trailing half-typed
+     * `**`, `` ` `` or `[label](htt` is withheld instead of being rendered as
+     * literal punctuation that vanishes one chunk later.
+     */
+    readonly streaming?: boolean;
+}
+
+/**
+ * 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
+ */
+declare class WrMarkdown {
+    private readonly highlight;
+    private readonly destroyRef;
+    /** The markdown source. */
+    readonly value: _angular_core.InputSignal<string>;
+    /**
+     * 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
+     */
+    readonly streaming: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * 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.
+     */
+    readonly copyable: _angular_core.InputSignalWithTransform<boolean | null, BooleanInput>;
+    /**
+     * 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.
+     */
+    readonly linkTarget: _angular_core.InputSignal<"_blank" | "_self" | null>;
+    /**
+     * Put a slugged `id` on every heading, so the document can be linked into.
+     *
+     * @default true
+     */
+    readonly headingIds: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * 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.
+     */
+    readonly headingIdPrefix: _angular_core.InputSignal<string>;
+    /** Accessible name of the copy button. Falls back to `markdown.copy`, then `'Copy code'`. */
+    readonly copyLabel: _angular_core.InputSignal<string | null>;
+    /** Announced after a successful copy. Falls back to `markdown.copied`, then `'Copied'`. */
+    readonly copiedLabel: _angular_core.InputSignal<string | null>;
+    /** Read out for a checked task item. Falls back to `markdown.taskDone`, then `'Done:'`. */
+    readonly taskDoneLabel: _angular_core.InputSignal<string | null>;
+    /** Read out for an unchecked task item. Falls back to `markdown.taskTodo`, then `'To do:'`. */
+    readonly taskTodoLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedCopyable: _angular_core.Signal<boolean>;
+    protected readonly resolvedLinkTarget: _angular_core.Signal<"_blank" | "_self" | null>;
+    protected readonly resolvedCopyLabel: _angular_core.Signal<string>;
+    protected readonly resolvedCopiedLabel: _angular_core.Signal<string>;
+    protected readonly resolvedTaskDoneLabel: _angular_core.Signal<string>;
+    protected readonly resolvedTaskTodoLabel: _angular_core.Signal<string>;
+    /**
+     * 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.
+     */
+    protected readonly blocks: _angular_core.Signal<readonly WrMarkdownBlock[]>;
+    /** `rel` is bound, not hard-coded, so a same-tab link does not carry a pointless one. */
+    protected readonly linkRel: _angular_core.Signal<"noopener noreferrer" | null>;
+    /**
+     * 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.
+     */
+    private readonly copiedBlock;
+    private copiedTimer;
+    constructor();
+    /**
+     * 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.
+     */
+    protected readonly newline: string;
+    /** Every code block in the document, nested ones included. */
+    private readonly codeBlocks;
+    /** Spans for a code block, or `null` to render it as plain text. */
+    protected linesOf(code: string, language: string | null): readonly WrHighlightLine[] | null;
+    protected isCopied(block: WrMarkdownBlock): boolean;
+    protected onCopied(block: WrMarkdownBlock): void;
+    /** A heading's id, namespaced, or `null` when there is nothing to link to. */
+    protected idOf(id: string): string | null;
+    /**
+     * 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.
+     */
+    protected hrefOf(href: string): string;
+    /**
+     * 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.
+     */
+    protected asBlocks(value: unknown): readonly WrMarkdownBlock[];
+    protected asInlines(value: unknown): readonly WrMarkdownInline[];
+    protected asItems(value: unknown): readonly WrMarkdownListItem[];
+    protected asCells(value: unknown): readonly WrMarkdownCell[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrMarkdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrMarkdown, "wr-markdown", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "copyable": { "alias": "copyable"; "required": false; "isSignal": true; }; "linkTarget": { "alias": "linkTarget"; "required": false; "isSignal": true; }; "headingIds": { "alias": "headingIds"; "required": false; "isSignal": true; }; "headingIdPrefix": { "alias": "headingIdPrefix"; "required": false; "isSignal": true; }; "copyLabel": { "alias": "copyLabel"; "required": false; "isSignal": true; }; "copiedLabel": { "alias": "copiedLabel"; "required": false; "isSignal": true; }; "taskDoneLabel": { "alias": "taskDoneLabel"; "required": false; "isSignal": true; }; "taskTodoLabel": { "alias": "taskTodoLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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.
+ */
+declare class WrMarkdownHighlight {
+    private readonly highlighter;
+    /** Language to code to answer. Insertion order is least-recently-rendered first. */
+    private readonly cache;
+    /** Bumped whenever an answer lands. Read by the template, never by a writer. */
+    private readonly revision;
+    private readonly generationSignal;
+    /**
+     * 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.
+     */
+    readonly generation: _angular_core.Signal<number>;
+    /** Spans for one block, or `null` for plain text. Safe to call from a template. */
+    linesFor(code: string, language: string | null): readonly WrHighlightLine[] | null;
+    /**
+     * 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(): void;
+    /**
+     * 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: string, language: string | null): void;
+    /**
+     * 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.
+     */
+    private fill;
+    /** `Map` iterates in insertion order, and `linesFor` re-inserts on read. */
+    private evict;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrMarkdownHighlight, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<WrMarkdownHighlight>;
+}
+
+/**
+ * @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
+ */
+declare function parseMarkdown(source: string, options?: WrMarkdownParseOptions): readonly WrMarkdownBlock[];
+/**
+ * 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.
+ */
+declare function safeMarkdownUrl(raw: string, kind: 'link' | 'image'): string | null;
+/** Inline markdown to nodes. */
+declare function parseInlines(source: string, options?: WrMarkdownParseOptions): readonly WrMarkdownInline[];
+/** Text content of an inline tree — for `alt` and for heading slugs. */
+declare function plainText(inlines: readonly WrMarkdownInline[]): string;
+
+/**
+ * @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);
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function provideWrMarkdownHighlighter(highlighter: WrMarkdownHighlighter | {
+    readonly useFactory: () => WrMarkdownHighlighter;
+}): EnvironmentProviders;
+
+/**
+ * @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()`.
+ */
+declare const WR_MARKDOWN_HIGHLIGHTER: InjectionToken<WrMarkdownHighlighter | null>;
+
+export { WR_MARKDOWN_HIGHLIGHTER, WrMarkdown, WrMarkdownHighlight, parseInlines, parseMarkdown, plainText, provideWrMarkdownHighlighter, safeMarkdownUrl };
+export type { WrHighlightLine, WrHighlightSpan, WrMarkdownAlign, WrMarkdownBlock, WrMarkdownCell, WrMarkdownHighlighter, WrMarkdownInline, WrMarkdownListItem, WrMarkdownParseOptions };

package/types/ngwr-marquee.d.ts

@@ -64,8 +64,18 @@ declare class WrMarquee {
     readonly fadeOutColor: _angular_core.InputSignal<string>;
     /** Scale individual items up on hover. @default false */
     readonly scaleOnHover: _angular_core.InputSignalWithTransform<boolean, any>;
-    /** Accessible label for the carousel region. @default 'Marquee' */
-    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the region. Falls back to `marquee.label`, then
+     * `'Marquee'`.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    /**
+     * Name used for an item that links somewhere but carries no text of its own.
+     * Falls back to `marquee.link`, then `'link'` — a bare `'link'` in English was
+     * what a screen reader announced for every unlabelled logo in the strip.
+     */
+    protected readonly resolvedLinkLabel: _angular_core.Signal<string>;
     private readonly trackEl;
     private readonly host;
     private readonly destroyRef;