@scalewing/react 1.40.0 → 1.42.0

package/dist/components/filter-chips/options.d.ts

@@ -0,0 +1,75 @@
+import { type RequiredMark } from '../FieldLabelText.js';
+export type FilterChipOption = {
+    value: string;
+    label: string;
+    count?: number;
+    disabled?: boolean;
+};
+/**
+ * How a chip's count is drawn: `figure` (the default), a muted tabular
+ * figure after a space; `inline`, the label's own words and type, after a
+ * middle dot ("Open · 3"), the dot hidden from assistive technology.
+ */
+export declare const filterChipCountAppearances: readonly ["figure", "inline"];
+export type FilterChipCountAppearance = (typeof filterChipCountAppearances)[number];
+/**
+ * What the chips do when they do not fit their row: `wrap` (the default)
+ * onto more rows, or `scroll` sideways on one row.
+ */
+export declare const filterChipsOverflows: readonly ["wrap", "scroll"];
+export type FilterChipsOverflow = (typeof filterChipsOverflows)[number];
+/** One chosen chip, a radio in a group. */
+type SingleChoice = {
+    multiple?: false;
+    /** The chosen option's value, or `''` while nothing is chosen yet. */
+    value: string;
+    onChange: (value: string) => void;
+    /**
+     * A choice must be made, such as a reason: each radio is `required` and
+     * the label shows the required mark (hidden from assistive technology,
+     * which reads the radios' own state).
+     */
+    required?: boolean;
+};
+/**
+ * Several chips on at once, each a checkbox, such as the days of a week.
+ * Nothing makes a checkbox group required, so `required` is refused: say
+ * what is needed in `error`.
+ */
+type MultipleChoice = {
+    multiple: true;
+    /** The chosen options' values, in any order; empty for none. */
+    value: readonly string[];
+    /** Every chosen value, in the options' order. */
+    onChange: (values: string[]) => void;
+    required?: false;
+};
+type FilterChipsChoice = SingleChoice | MultipleChoice;
+export type FilterChipsProps = FilterChipsChoice & {
+    label: string;
+    options: readonly FilterChipOption[];
+    /**
+     * Keeps the label as the group's name but does not draw it, for chips
+     * whose meaning their words and place already show.
+     */
+    labelVisuallyHidden?: boolean;
+    /**
+     * `hidden` leaves out the label's " *" while the control stays required
+     * (and announced so); `visible` (default) draws it.
+     * When hidden, say in visible text which fields must be filled; a
+     * placeholder alone is not enough.
+     */
+    requiredMark?: RequiredMark;
+    countAppearance?: FilterChipCountAppearance;
+    overflow?: FilterChipsOverflow;
+    /**
+     * A message under the chips, such as "Pick a reason": a polite live
+     * region linked to the group by `aria-describedby`; the group is marked
+     * invalid and every chip takes the danger edge. An empty string is no
+     * error.
+     */
+    error?: string;
+    /** More ids that describe the group, such as a hint beside it. */
+    'aria-describedby'?: string;
+};
+export {};

package/dist/components/filter-chips/options.js

@@ -0,0 +1,11 @@
+/**
+ * How a chip's count is drawn: `figure` (the default), a muted tabular
+ * figure after a space; `inline`, the label's own words and type, after a
+ * middle dot ("Open · 3"), the dot hidden from assistive technology.
+ */
+export const filterChipCountAppearances = ['figure', 'inline'];
+/**
+ * What the chips do when they do not fit their row: `wrap` (the default)
+ * onto more rows, or `scroll` sideways on one row.
+ */
+export const filterChipsOverflows = ['wrap', 'scroll'];

package/dist/components/filter-chips/validate.d.ts

@@ -0,0 +1,9 @@
+import { type FilterChipsProps } from './options.js';
+/**
+ * Fails closed on chips it cannot draw: an empty label, no options, blank
+ * or repeated values, a chosen value that is no option, a count that is
+ * not a whole number from 0, an unknown count appearance or overflow, and
+ * a multiple choice asked to be required or given a value that is not a
+ * list.
+ */
+export declare function assertFilterChips(props: FilterChipsProps): void;

package/dist/components/filter-chips/validate.js

@@ -0,0 +1,48 @@
+import { assertRequiredMark } from '../FieldLabelText.js';
+import { filterChipCountAppearances, filterChipsOverflows, } from './options.js';
+function isCount(count) {
+    return count === undefined || (Number.isInteger(count) && count >= 0);
+}
+function chosenValues(props) {
+    if (props.multiple)
+        return props.value;
+    return props.value === '' ? [] : [props.value];
+}
+/**
+ * Fails closed on chips it cannot draw: an empty label, no options, blank
+ * or repeated values, a chosen value that is no option, a count that is
+ * not a whole number from 0, an unknown count appearance or overflow, and
+ * a multiple choice asked to be required or given a value that is not a
+ * list.
+ */
+export function assertFilterChips(props) {
+    const { label, options } = props;
+    if (!label.trim())
+        throw new RangeError('label must not be empty');
+    assertRequiredMark(props.requiredMark ?? 'visible');
+    if (options.length === 0 ||
+        options.some((option) => !option.value.trim() || !option.label.trim()))
+        throw new RangeError('options must have nonempty values and labels');
+    const values = options.map((option) => option.value);
+    if (new Set(values).size !== values.length)
+        throw new RangeError('options must have unique values');
+    if (props.multiple) {
+        if (!Array.isArray(props.value))
+            throw new RangeError('a multiple FilterChips value must be a list');
+        if (props.required)
+            throw new RangeError('a multiple FilterChips cannot be required; say what is needed in error');
+    }
+    const chosen = chosenValues(props);
+    if (chosen.some((value) => !values.includes(value)))
+        throw new RangeError(props.multiple
+            ? 'every value must match an option'
+            : 'value must match an option or be empty');
+    if (options.some((option) => !isCount(option.count)))
+        throw new RangeError('count must be a non-negative integer');
+    const countAppearance = props.countAppearance ?? 'figure';
+    if (!filterChipCountAppearances.includes(countAppearance))
+        throw new RangeError(`Unknown FilterChips countAppearance: ${String(countAppearance)}`);
+    const overflow = props.overflow ?? 'wrap';
+    if (!filterChipsOverflows.includes(overflow))
+        throw new RangeError(`Unknown FilterChips overflow: ${String(overflow)}`);
+}

package/dist/components/list/ListRowContent.d.ts

@@ -1,4 +1,5 @@
 import { type ReactNode } from 'react';
+import { type BadgeTone } from '../../css/css-data.js';
 import { type ListRowAccessory, type ListRowTitleAppearance, type ListRowTone, type ListRowValueTone } from '../../list-options.js';
 export type ListRowContentProps = {
     /** Prefixes the ids that name and describe a pressable row. */
@@ -8,13 +9,18 @@ export type ListRowContentProps = {
     value?: string;
     valueDetail?: string;
     valueTone?: ListRowValueTone;
+    valueBadge?: BadgeTone;
     leading?: ReactNode;
     tone: ListRowTone;
     titleAppearance: ListRowTitleAppearance;
     accessory: ListRowAccessory;
+    /** The unread words; the dot shows while they are given. */
+    unreadLabel?: string;
+    tag?: ReactNode;
 };
 /**
  * A list row's parts in reading order: the hidden leading mark, the title
- * over its detail, the value over its detail, then the chevron or check.
+ * (with the unread dot and its hidden words) over its detail, the value
+ * over its detail, the tag, then the chevron or check.
  */
-export declare function ListRowContent({ id, title, detail, value, valueDetail, valueTone, leading, tone, titleAppearance, accessory, }: ListRowContentProps): import("react").JSX.Element;
+export declare function ListRowContent({ id, title, detail, value, valueDetail, valueTone, valueBadge, leading, tone, titleAppearance, accessory, unreadLabel, tag, }: ListRowContentProps): import("react").JSX.Element;

package/dist/components/list/ListRowContent.js

@@ -1,10 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { cx } from '../../class-names.js';
+import { Badge } from '../Badge.js';
 import { ListRowAccessoryMark } from './ListRowAccessoryMark.js';
+import { hasSlot } from './row-slot.js';
 /**
  * A list row's parts in reading order: the hidden leading mark, the title
- * over its detail, the value over its detail, then the chevron or check.
+ * (with the unread dot and its hidden words) over its detail, the value
+ * over its detail, the tag, then the chevron or check.
  */
-export function ListRowContent({ id, title, detail, value, valueDetail, valueTone, leading, tone, titleAppearance, accessory, }) {
-    return (_jsxs(_Fragment, { children: [leading === undefined ? null : (_jsx("span", { "aria-hidden": "true", className: "sw-list-row-leading", children: leading })), _jsxs("span", { className: "sw-list-row-label", children: [_jsx("span", { className: cx('sw-list-row-title', titleAppearance === 'plain' && 'sw-list-row-title-plain', tone === 'danger' && 'sw-list-row-title-danger'), id: `${id}-title`, children: title }), detail ? (_jsx("span", { className: "sw-list-row-detail", id: `${id}-detail`, children: detail })) : null] }), value === undefined ? null : (_jsxs("span", { className: "sw-list-row-end", children: [_jsx("span", { className: cx('sw-list-row-value', valueTone && `sw-list-row-value-${valueTone}`), id: `${id}-value`, children: value }), valueDetail ? (_jsx("span", { className: "sw-list-row-value-detail", id: `${id}-value-detail`, children: valueDetail })) : null] })), _jsx(ListRowAccessoryMark, { kind: accessory })] }));
+export function ListRowContent({ id, title, detail, value, valueDetail, valueTone, valueBadge, leading, tone, titleAppearance, accessory, unreadLabel, tag, }) {
+    return (_jsxs(_Fragment, { children: [!hasSlot(leading) ? null : (_jsx("span", { "aria-hidden": "true", className: "sw-list-row-leading", children: leading })), _jsxs("span", { className: "sw-list-row-label", children: [_jsxs("span", { className: cx('sw-list-row-title', titleAppearance === 'plain' && 'sw-list-row-title-plain', tone === 'danger' && 'sw-list-row-title-danger'), id: `${id}-title`, children: [title, unreadLabel === undefined ? null : (_jsx("span", { "aria-hidden": "true", className: "sw-list-row-unread" }))] }), unreadLabel === undefined ? null : (_jsx("span", { className: "sw-sr-only", id: `${id}-unread`, children: unreadLabel })), detail ? (_jsx("span", { className: "sw-list-row-detail", id: `${id}-detail`, children: detail })) : null] }), value === undefined ? null : (_jsxs("span", { className: "sw-list-row-end", children: [_jsx("span", { className: cx('sw-list-row-value', valueTone && `sw-list-row-value-${valueTone}`), id: `${id}-value`, children: valueBadge ? _jsx(Badge, { tone: valueBadge, children: value }) : value }), valueDetail ? (_jsx("span", { className: "sw-list-row-value-detail", id: `${id}-value-detail`, children: valueDetail })) : null] })), !hasSlot(tag) ? null : (_jsx("span", { className: "sw-list-row-tag", id: `${id}-tag`, children: tag })), _jsx(ListRowAccessoryMark, { kind: accessory })] }));
 }

package/dist/components/list/ListRowItem.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+/**
+ * A row's list item: an `li` in a ListGroup's list, a `div` elsewhere. A
+ * row with an `action` holds that control after the row, a sibling of the
+ * row's button or link, so it is never inside the row's press area.
+ */
+export declare function ListRowItem({ action, children, }: {
+    action: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/components/list/ListRowItem.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext } from 'react';
+import { cx } from '../../class-names.js';
+import { ListRowContainer } from './list-row-container.js';
+import { hasSlot } from './row-slot.js';
+/**
+ * A row's list item: an `li` in a ListGroup's list, a `div` elsewhere. A
+ * row with an `action` holds that control after the row, a sibling of the
+ * row's button or link, so it is never inside the row's press area.
+ */
+export function ListRowItem({ action, children, }) {
+    const container = useContext(ListRowContainer);
+    const hasAction = hasSlot(action);
+    const content = (_jsxs(_Fragment, { children: [children, hasAction ? _jsx("div", { className: "sw-list-row-action", children: action }) : null] }));
+    const className = cx('sw-list-item', hasAction && 'sw-list-item-action');
+    return container === 'li' ? (_jsx("li", { className: className, children: content })) : (_jsx("div", { className: className, children: content }));
+}

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[];