@scalewing/react 1.41.0 → 1.42.0

package/dist/components/list/row-naming.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+/**
+ * A pressable row's name (its title, the unread words and its value) and
+ * description (its detail lines and its tag), by the ids its parts carry.
+ */
+export declare function rowNaming(id: string, row: {
+    'aria-label'?: string;
+    value?: string;
+    detail?: string;
+    valueDetail?: string;
+    unread: boolean;
+    tag?: ReactNode;
+}): {
+    'aria-label': string | undefined;
+    'aria-labelledby': string | undefined;
+    'aria-describedby': string | undefined;
+};

package/dist/components/list/row-naming.js

@@ -0,0 +1,19 @@
+import { hasSlot } from './row-slot.js';
+function ids(...parts) {
+    const joined = parts.filter(Boolean).join(' ');
+    return joined === '' ? undefined : joined;
+}
+/**
+ * A pressable row's name (its title, the unread words and its value) and
+ * description (its detail lines and its tag), by the ids its parts carry.
+ */
+export function rowNaming(id, row) {
+    const hasTag = hasSlot(row.tag);
+    return {
+        'aria-label': row['aria-label'],
+        'aria-labelledby': row['aria-label']
+            ? undefined
+            : ids(`${id}-title`, row.unread && `${id}-unread`, row.value !== undefined && `${id}-value`),
+        'aria-describedby': ids(Boolean(row.detail) && `${id}-detail`, Boolean(row.valueDetail) && `${id}-value-detail`, hasTag && `${id}-tag`),
+    };
+}

package/dist/components/list/row-slot.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+/**
+ * Whether a row's slot (`leading`, `tag`, `action`) holds something to
+ * draw. As React renders nothing for them, `undefined`, `null`, a boolean
+ * (the `false` of `canArchive && <ActionMenu …/>`) and an empty string are
+ * an empty slot, so they add no box and no gap.
+ */
+export declare function hasSlot(node: ReactNode): boolean;

package/dist/components/list/row-slot.js

@@ -0,0 +1,12 @@
+/**
+ * Whether a row's slot (`leading`, `tag`, `action`) holds something to
+ * draw. As React renders nothing for them, `undefined`, `null`, a boolean
+ * (the `false` of `canArchive && <ActionMenu …/>`) and an empty string are
+ * an empty slot, so they add no box and no gap.
+ */
+export function hasSlot(node) {
+    return (node !== undefined &&
+        node !== null &&
+        node !== '' &&
+        typeof node !== 'boolean');
+}

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

@@ -0,0 +1,14 @@
+/** How many quotes and lists the view draws inside one another. */
+export declare const maxNesting = 16;
+/**
+ * How deep the parser reads (a quote is one level, a list and its item
+ * two). markdown-it stops reading a block that nests deeper (its words are
+ * lost, and reported as `limit`). Its work on runs of link and image
+ * openers grows with this cap, so it stays low: 128 keeps 60-deep lists
+ * and reads 25,000 `![` in about 0.1 s.
+ */
+export declare const maxParseNesting = 128;
+/** The longest excerpt an omission keeps. */
+export declare const maxExcerpt = 80;
+/** How many omissions the reading lists; the counts keep the rest. */
+export declare const maxOmissionsListed = 100;

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

@@ -0,0 +1,14 @@
+/** How many quotes and lists the view draws inside one another. */
+export const maxNesting = 16;
+/**
+ * How deep the parser reads (a quote is one level, a list and its item
+ * two). markdown-it stops reading a block that nests deeper (its words are
+ * lost, and reported as `limit`). Its work on runs of link and image
+ * openers grows with this cap, so it stays low: 128 keeps 60-deep lists
+ * and reads 25,000 `![` in about 0.1 s.
+ */
+export const maxParseNesting = 128;
+/** The longest excerpt an omission keeps. */
+export const maxExcerpt = 80;
+/** How many omissions the reading lists; the counts keep the rest. */
+export const maxOmissionsListed = 100;

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

@@ -0,0 +1,94 @@
+/** A run of text and its marks, as the view draws it. */
+export type MarkdownInline = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'strong' | 'emphasis';
+    children: MarkdownInline[];
+} | {
+    kind: 'link';
+    href: string;
+    children: MarkdownInline[];
+} | {
+    kind: 'break';
+};
+/** A block of the page, as the view draws it. */
+export type MarkdownBlock = {
+    kind: 'paragraph';
+    children: MarkdownInline[];
+} | {
+    kind: 'heading';
+    level: 1 | 2 | 3;
+    id: string;
+    children: MarkdownInline[];
+} | {
+    kind: 'list';
+    ordered: boolean;
+    start: number | null;
+    tight: boolean;
+    items: MarkdownBlock[][];
+} | {
+    kind: 'quote';
+    children: MarkdownBlock[];
+} | {
+    kind: 'figure';
+    src: string;
+    alt: string;
+    caption: string;
+} | {
+    kind: 'rule';
+};
+/** A heading of the page, for an "On this page" list. */
+export type MarkdownHeading = {
+    /** The heading's element id, for a link to it (`#${id}`). */
+    id: string;
+    /** 1 for `#`, 2 for `##`, 3 for `###` (and deeper). */
+    level: 1 | 2 | 3;
+    text: string;
+};
+/** What the view leaves out of the Markdown it is given. */
+export type MarkdownOmissionKind = 
+/** Raw HTML, scripts included: dropped (the words between tags stay). */
+'html'
+/** A table: dropped. */
+ | 'table'
+/** An image that is not a `photo:` the consumer resolves: dropped. */
+ | 'image'
+/** A link whose scheme is not http, https or mailto: shown as its words. */
+ | 'link'
+/** Code: shown as plain text, without its code formatting. */
+ | 'code'
+/**
+ * Past the view's limits: quotes, lists and marks nested more than 16
+ * deep are shown as their words (a link there too, quoted in the run's
+ * one omission); a block reaching the parser's 128th level, past which
+ * it stops reading, is reported as it may be lost.
+ */
+ | 'limit';
+export declare const markdownOmissionKinds: readonly ["html", "table", "image", "link", "code", "limit"];
+/** How many of each kind the view left out, the ones past the list too. */
+export type MarkdownOmissionCounts = Record<MarkdownOmissionKind, number>;
+export type MarkdownOmission = {
+    kind: MarkdownOmissionKind;
+    /** The Markdown it came from, cut to 80 characters. */
+    source: string;
+};
+/** A `photo:` image as the consumer resolves it. */
+export type MarkdownImage = {
+    /**
+     * The photo's address: relative, `https:`, `http:`, `blob:` or a
+     * `data:image/` of PNG, JPEG, GIF, WebP, AVIF or SVG; any other is left out.
+     */
+    src: string;
+    /** What the photo shows; the caption is used when this is left out. */
+    alt?: string;
+};
+export type MarkdownImageResolver = (id: string) => MarkdownImage | null;
+/** The page read from Markdown: its blocks, its headings, what was left out. */
+export type MarkdownReading = {
+    blocks: MarkdownBlock[];
+    headings: MarkdownHeading[];
+    /** The first 100 things left out, in the order they appear. */
+    omissions: MarkdownOmission[];
+    omissionCounts: MarkdownOmissionCounts;
+};

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

@@ -0,0 +1,8 @@
+export const markdownOmissionKinds = [
+    'html',
+    'table',
+    'image',
+    'link',
+    'code',
+    'limit',
+];

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

@@ -0,0 +1,18 @@
+import { type MarkdownImageResolver } from './markdown-model.js';
+export type MarkdownOptions = {
+    /**
+     * Turns `![caption](photo:<id>)` into a photo: its `src` and its `alt`
+     * (the caption when left out); null leaves it out. Any other image is
+     * left out. A new function reads the source again, so keep it stable
+     * (`useCallback`) where the view renders often.
+     */
+    resolveImage?: MarkdownImageResolver;
+    /**
+     * Put before every heading id, such as "page-", so its ids never clash
+     * with the page's or another view's (`''`, the default, is none). Pass
+     * the same one to the view and to `inspectMarkdown`.
+     */
+    idPrefix?: string;
+};
+/** Refuses what neither the view nor `inspectMarkdown` can read. */
+export declare function assertMarkdownInput(owner: string, source: unknown, { resolveImage, idPrefix }: MarkdownOptions): void;

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

@@ -0,0 +1,10 @@
+/** Refuses what neither the view nor `inspectMarkdown` can read. */
+export function assertMarkdownInput(owner, source, { resolveImage, idPrefix }) {
+    if (typeof source !== 'string')
+        throw new RangeError(`${owner} source must be text`);
+    if (resolveImage !== undefined && typeof resolveImage !== 'function')
+        throw new RangeError(`${owner} resolveImage must be a function`);
+    if (idPrefix !== undefined &&
+        (typeof idPrefix !== 'string' || !/^([A-Za-z][\w-]*)?$/.test(idPrefix)))
+        throw new RangeError(`${owner} idPrefix must be empty or start with a letter and hold letters, digits, - or _`);
+}

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

@@ -0,0 +1,28 @@
+/** The link schemes a page may use; any other is shown as plain words. */
+export declare const markdownLinkSchemes: readonly ["http:", "https:", "mailto:"];
+/**
+ * The address a link may open, normalised as the browser reads it, or null
+ * for any scheme but http, https and mailto (`javascript:`, `data:`, a
+ * relative or protocol-relative address, anything that is not a URL).
+ */
+export declare function safeLinkHref(url: string): string | null;
+/** The id in `photo:<id>`, or null for any other image address. */
+export declare function photoId(url: string): string | null;
+/**
+ * Whether a resolved photo's address may be drawn: relative, `https:`,
+ * `http:`, `blob:` or a `data:` PNG, JPEG, GIF, WebP, AVIF or SVG (an
+ * `img` never runs an SVG's script); never any other scheme.
+ */
+export declare function isSafeImageSrc(src: string): boolean;
+/**
+ * Heading ids for one document: from a heading's words, `section` when
+ * nothing is left, after `prefix`; a repeat takes the next free `-2`,
+ * `-3`. Each base remembers its next number, so many repeats stay linear.
+ */
+export declare class HeadingIds {
+    private readonly prefix;
+    private readonly taken;
+    private readonly next;
+    constructor(prefix: string);
+    take(text: string): string;
+}

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

@@ -0,0 +1,81 @@
+/** The link schemes a page may use; any other is shown as plain words. */
+export const markdownLinkSchemes = ['http:', 'https:', 'mailto:'];
+/**
+ * The address a link may open, normalised as the browser reads it, or null
+ * for any scheme but http, https and mailto (`javascript:`, `data:`, a
+ * relative or protocol-relative address, anything that is not a URL).
+ */
+export function safeLinkHref(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    return markdownLinkSchemes.includes(parsed.protocol)
+        ? parsed.href
+        : null;
+}
+/** The id in `photo:<id>`, or null for any other image address. */
+export function photoId(url) {
+    const match = /^photo:([A-Za-z0-9_-]{1,64})$/.exec(url.trim());
+    return match ? match[1] : null;
+}
+const imageSchemes = ['http:', 'https:', 'blob:'];
+const imageData = /^data:image\/(png|jpeg|gif|webp|avif|svg\+xml)[;,]/i;
+/**
+ * Whether a resolved photo's address may be drawn: relative, `https:`,
+ * `http:`, `blob:` or a `data:` PNG, JPEG, GIF, WebP, AVIF or SVG (an
+ * `img` never runs an SVG's script); never any other scheme.
+ */
+export function isSafeImageSrc(src) {
+    if (typeof src !== 'string' || src.trim() === '')
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(src, 'https://relative.invalid/');
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol === 'data:')
+        return imageData.test(src.trim());
+    return imageSchemes.includes(parsed.protocol);
+}
+/** A heading's words as an id: lower case, accents dropped, hyphens. */
+function slug(text) {
+    return text
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Heading ids for one document: from a heading's words, `section` when
+ * nothing is left, after `prefix`; a repeat takes the next free `-2`,
+ * `-3`. Each base remembers its next number, so many repeats stay linear.
+ */
+export class HeadingIds {
+    prefix;
+    taken = new Set();
+    next = new Map();
+    constructor(prefix) {
+        this.prefix = prefix;
+    }
+    take(text) {
+        const base = `${this.prefix}${slug(text) || 'section'}`;
+        let id = base;
+        let count = this.next.get(base) ?? 2;
+        if (this.taken.has(id)) {
+            do {
+                id = `${base}-${count}`;
+                count += 1;
+            } while (this.taken.has(id));
+        }
+        this.next.set(base, count);
+        this.taken.add(id);
+        return id;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { type MarkdownInline } from './markdown-model.js';
+import { type Token } from './parse-markdown.js';
+import { type ReadingContext } from './reading-context.js';
+/** Left-out text as an omission quotes it: trimmed, at most `maxExcerpt`. */
+export declare function excerpt(text: string): string;
+/** A run's words without its marks. */
+export declare function plainText(inlines: readonly MarkdownInline[]): string;
+/**
+ * The words of `tokens` (block tokens, or one block's inline children),
+ * in order, at any depth: a flat walk, so no nesting overflows the stack.
+ * Raw HTML, tables and images are never words: each is noted as left out.
+ */
+export declare function tokenText(context: ReadingContext, tokens: readonly Token[]): string;
+/** Code shown as plain lines, a break between each. */
+export declare function lines(value: string): MarkdownInline[];
+/** Drops the spaces an image left at a paragraph part's edges. */
+export declare function trimEdges(inlines: MarkdownInline[]): MarkdownInline[];

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

@@ -0,0 +1,86 @@
+import { maxExcerpt } from './markdown-limits.js';
+/** Left-out text as an omission quotes it: trimmed, at most `maxExcerpt`. */
+export function excerpt(text) {
+    const trimmed = text.trim();
+    return trimmed.length > maxExcerpt
+        ? `${trimmed.slice(0, maxExcerpt - 1)}…`
+        : trimmed;
+}
+/** A run's words without its marks. */
+export function plainText(inlines) {
+    return inlines
+        .map((inline) => {
+        if (inline.kind === 'text')
+            return inline.value;
+        if (inline.kind === 'break')
+            return ' ';
+        return plainText(inline.children);
+    })
+        .join('');
+}
+/**
+ * The words of `tokens` (block tokens, or one block's inline children),
+ * in order, at any depth: a flat walk, so no nesting overflows the stack.
+ * Raw HTML, tables and images are never words: each is noted as left out.
+ */
+export function tokenText(context, tokens) {
+    const words = [];
+    let table = null;
+    for (const token of tokens) {
+        if (table !== null) {
+            if (token.type === 'table_close' && token.level === table.level)
+                table = null;
+            continue;
+        }
+        switch (token.type) {
+            case 'table_open':
+                context.omitBlock('table', token);
+                table = token;
+                break;
+            case 'html_block':
+            case 'html_inline':
+                context.omit('html', token.content);
+                break;
+            case 'image':
+                context.omit('image', `![${token.content}](${token.attrGet('src') ?? ''})`);
+                break;
+            case 'inline':
+                words.push(tokenText(context, token.children ?? []));
+                break;
+            case 'text':
+            case 'code_inline':
+            case 'code_block':
+            case 'fence':
+                words.push(token.content);
+                break;
+            case 'softbreak':
+            case 'hardbreak':
+                words.push(' ');
+                break;
+            default:
+                break;
+        }
+    }
+    return words.join(' ').replace(/\s+/g, ' ').trim();
+}
+/** Code shown as plain lines, a break between each. */
+export function lines(value) {
+    return value
+        .replace(/\n$/, '')
+        .split('\n')
+        .flatMap((line, index) => {
+        const text = { kind: 'text', value: line };
+        return index === 0 ? [text] : [{ kind: 'break' }, text];
+    });
+}
+/** Drops the spaces an image left at a paragraph part's edges. */
+export function trimEdges(inlines) {
+    const result = [...inlines];
+    const first = result[0];
+    if (first?.kind === 'text')
+        result[0] = { kind: 'text', value: first.value.trimStart() };
+    const last = result[result.length - 1];
+    if (last?.kind === 'text')
+        result[result.length - 1] = { kind: 'text', value: last.value.trimEnd() };
+    return result;
+}

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

@@ -0,0 +1,4 @@
+import { type Token } from 'markdown-it';
+export type { Token };
+/** The block tokens of `source`; inline tokens are each block's `children`. */
+export declare function parseMarkdown(source: string): Token[];

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

@@ -0,0 +1,21 @@
+import MarkdownIt from 'markdown-it';
+import { maxParseNesting } from './markdown-limits.js';
+/*
+ * CommonMark with GFM tables (recognised only so they are left out whole)
+ * and raw HTML read as HTML tokens (so they are left out, never shown as
+ * text), as a token stream. Its renderer is never called: nothing here
+ * makes HTML. Every link is read as a link (the view decides on its
+ * address); links are never found in bare text.
+ */
+// `maxNesting` is read by markdown-it's parsers; its types leave it out.
+const options = {
+    html: true,
+    linkify: false,
+    maxNesting: maxParseNesting,
+};
+const parser = new MarkdownIt('commonmark', options).enable('table');
+parser.validateLink = () => true;
+/** The block tokens of `source`; inline tokens are each block's `children`. */
+export function parseMarkdown(source) {
+    return parser.parse(source, {});
+}

package/dist/components/markdown/read-blocks.d.ts

@@ -0,0 +1,8 @@
+import { type MarkdownBlock } from './markdown-model.js';
+import { type Token } from './parse-markdown.js';
+import { type ReadingContext } from './reading-context.js';
+/**
+ * Block tokens as the view draws them; `depth` counts the quotes and
+ * lists around. Past `maxNesting`, a quote or list is its words.
+ */
+export declare function readBlocks(context: ReadingContext, tokens: readonly Token[], depth?: number): MarkdownBlock[];

package/dist/components/markdown/read-blocks.js

@@ -0,0 +1,168 @@
+import { maxNesting } from './markdown-limits.js';
+import { isSafeImageSrc, photoId } from './markdown-rules.js';
+import { lines, plainText, tokenText, trimEdges } from './markdown-text.js';
+import { attr, readInlines } from './read-inlines.js';
+/** The index of the token that closes the one at `index` (or `index`). */
+function closeOf(tokens, index) {
+    const open = tokens[index];
+    if (open.nesting !== 1)
+        return index;
+    for (let at = index + 1; at < tokens.length; at += 1) {
+        const token = tokens[at];
+        if (token.nesting === -1 && token.level === open.level)
+            return at;
+    }
+    return tokens.length - 1;
+}
+/** Each part of `tokens` opened by a token of `type`, without its own open and close. */
+function partsOf(tokens, type) {
+    const parts = [];
+    for (let at = 0; at < tokens.length; at += 1) {
+        if (tokens[at].type !== type)
+            continue;
+        const end = closeOf(tokens, at);
+        parts.push(tokens.slice(at + 1, end));
+        at = end;
+    }
+    return parts;
+}
+/**
+ * Block tokens as the view draws them; `depth` counts the quotes and
+ * lists around. Past `maxNesting`, a quote or list is its words.
+ */
+export function readBlocks(context, tokens, depth = 0) {
+    const blocks = [];
+    for (let at = 0; at < tokens.length; at += 1) {
+        const token = tokens[at];
+        const end = closeOf(tokens, at);
+        const inner = tokens.slice(at + 1, end);
+        at = end;
+        switch (token.type) {
+            case 'paragraph_open':
+                blocks.push(...readParagraph(context, inner[0]?.children ?? []));
+                break;
+            case 'heading_open': {
+                const children = readInlines(context, inner[0]?.children ?? []);
+                const text = plainText(children).trim();
+                const level = Math.min(Number(token.tag.slice(1)), 3);
+                const id = context.ids.take(text);
+                context.headings.push({ id, level, text });
+                blocks.push({ kind: 'heading', level, id, children });
+                break;
+            }
+            case 'bullet_list_open':
+            case 'ordered_list_open':
+            case 'blockquote_open': {
+                if (depth >= maxNesting) {
+                    context.omitBlock('limit', token);
+                    const text = tokenText(context, inner);
+                    if (text)
+                        blocks.push({
+                            kind: 'paragraph',
+                            children: [{ kind: 'text', value: text }],
+                        });
+                    break;
+                }
+                if (token.type === 'blockquote_open') {
+                    blocks.push({
+                        kind: 'quote',
+                        children: readBlocks(context, inner, depth + 1),
+                    });
+                    break;
+                }
+                const ordered = token.type === 'ordered_list_open';
+                blocks.push({
+                    kind: 'list',
+                    ordered,
+                    start: ordered ? Number(attr(token, 'start') ?? 1) : null,
+                    // A tight list's paragraphs are hidden: only their words show.
+                    tight: inner.every((child) => child.type !== 'paragraph_open' ||
+                        child.level !== token.level + 2 ||
+                        child.hidden),
+                    items: partsOf(inner, 'list_item_open').map((item) => readBlocks(context, item, depth + 1)),
+                });
+                break;
+            }
+            case 'code_block':
+            case 'fence':
+                context.omitBlock('code', token);
+                // An empty block draws nothing.
+                if (token.content.trim() !== '')
+                    blocks.push({ kind: 'paragraph', children: lines(token.content) });
+                break;
+            case 'hr':
+                blocks.push({ kind: 'rule' });
+                break;
+            case 'html_block':
+                context.omit('html', token.content);
+                break;
+            case 'table_open':
+                context.omitBlock('table', token);
+                break;
+            default:
+                // Nothing else is parsed at this level.
+                break;
+        }
+    }
+    return blocks;
+}
+/**
+ * A `photo:` the consumer resolves to a safe address, with words for it
+ * (its `alt`, or the caption): anything else is left out.
+ */
+function readFigure(context, image) {
+    const src = attr(image, 'src') ?? '';
+    const caption = plainText(readInlines(context, image.children ?? [])).trim();
+    const id = photoId(src);
+    const photo = id === null ? null : (context.options.resolveImage?.(id) ?? null);
+    // The caption names a photo without its own words, so it is never
+    // announced as decorative (screen readers then also read the caption).
+    const alt = (typeof photo?.alt === 'string' ? photo.alt.trim() : '') || caption;
+    if (!photo || !isSafeImageSrc(photo.src) || alt === '') {
+        context.omit('image', `![${image.content}](${src})`);
+        return null;
+    }
+    return { kind: 'figure', src: photo.src, alt, caption };
+}
+/**
+ * A paragraph, split around the photos in it (outside links and marks),
+ * which are figures of their own; an image left out leaves the paragraph
+ * whole, one space where it was.
+ */
+function readParagraph(context, children) {
+    const blocks = [];
+    let run = [];
+    let level = 0;
+    let dropped = false;
+    const flush = () => {
+        const inlines = readInlines(context, run);
+        if (plainText(inlines).trim() !== '')
+            blocks.push({ kind: 'paragraph', children: trimEdges(inlines) });
+        run = [];
+    };
+    for (const child of children) {
+        if (child.type === 'image' && level === 0) {
+            const figure = readFigure(context, child);
+            if (figure) {
+                flush();
+                blocks.push(figure);
+                dropped = false;
+            }
+            else
+                dropped = true;
+            continue;
+        }
+        level += child.nesting;
+        const before = run[run.length - 1];
+        if (dropped &&
+            child.type === 'text' &&
+            before?.type === 'text' &&
+            /\s$/.test(before.content))
+            run.push({ ...child, content: child.content.trimStart() });
+        else
+            run.push(child);
+        dropped = false;
+    }
+    flush();
+    return blocks;
+}

package/dist/components/markdown/read-inlines.d.ts

@@ -0,0 +1,12 @@
+import { type MarkdownInline } from './markdown-model.js';
+import { type Token } from './parse-markdown.js';
+import { type ReadingContext } from './reading-context.js';
+/** A token's attribute, read without its methods (tokens may be copies). */
+export declare function attr(token: Token, name: string): string | null;
+/**
+ * One block's inline tokens as the view's inlines: text, breaks, bold,
+ * italic and links. A link's address must pass `safeLinkHref`, or its
+ * words stay as text; raw HTML and images here are left out; code is its
+ * words; marks nested past `maxNesting` are their words.
+ */
+export declare function readInlines(context: ReadingContext, tokens: readonly Token[]): MarkdownInline[];