@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/markdown-lite.js

@@ -0,0 +1,705 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * Markdown-lite (AGL-123): the tiny subset blog entries use — headings,
+ * bold/italic, links, images, bullet and numbered lists, paragraphs, fenced
+ * code blocks, tables and blockquotes. Parsed into plain data blocks that
+ * renderers turn into elements themselves (no HTML string is ever produced,
+ * so there is nothing to sanitize).
+ */ import { isMediaRef, parseMediaRef } from "./media-ref.js";
+import { parseCollectionLinkValue, parseEntryLinkValue, parseFeedLinkValue, parseScreenLinkValue, resolveScreenHref, SCREEN_LINK_VALUE_PREFIX, screenRoutesAnswerFor } from "./screen-link-value.js";
+const INLINE_PATTERN = /(\*\*([^*]+)\*\*)|(\*([^*]+)\*)|(\[([^\]]+)\]\(([^)\s]+)\))/g;
+/**
+ * Only absolute http(s) survives; anything else renders as text. The `http:`
+ * half reaches LINKS only — {@link safeImageUrl} refuses it before it gets
+ * here (AGL-1713).
+ */ function safeUrl(url) {
+    return /^https?:\/\//i.test(url) ? url : null;
+}
+/**
+ * Whether a link target is one the parser will keep — the PUBLIC half of
+ * {@link safeLinkUrl}, so an editor can refuse what the parser would drop
+ * instead of discovering the disagreement on the published page (AGL-1686).
+ */ export function isSupportedLinkHref(url) {
+    return safeLinkUrl(url) !== null;
+}
+/**
+ * Whether an image source is one the parser will keep. The predicate an
+ * authoring surface must validate against, for the reason
+ * {@link isSupportedLinkHref} exists and one the editor learned the hard way:
+ * AGL-1645 widened the visual editor's image check to accept site-relative
+ * paths without widening this file, so every image picked from the media
+ * library serialized into the document and then vanished on the next parse.
+ * One predicate, two callers, no drift.
+ */ export function isSupportedImageSrc(url) {
+    return safeImageUrl(url) !== null;
+}
+/**
+ * Whether a link target is a stored REFERENCE rather than an address
+ * (AGL-3118): a screen, a collection listing, an entry or a feed, named by id
+ * so a rename cannot break it. Only the marked, well-formed forms count — a
+ * bare id is indistinguishable from a relative path with no slash, so it
+ * stays what the dialect has always made of it.
+ *
+ * Kept verbatim in the parsed link: a renderer resolves it against the same
+ * routing map element links use, and the serializer writes it back as typed.
+ */ export function isMarkdownLinkReference(url) {
+    if (url.startsWith(SCREEN_LINK_VALUE_PREFIX)) {
+        return parseScreenLinkValue(url) !== undefined;
+    }
+    return parseCollectionLinkValue(url) !== undefined || parseEntryLinkValue(url) !== undefined || parseFeedLinkValue(url) !== undefined;
+}
+/**
+ * Link targets additionally allow SITE-RELATIVE paths (AGL-582) so entry
+ * markdown can link to other pages of the same site — renderers give those
+ * client-side navigation — and link REFERENCES (AGL-3118), which renderers
+ * resolve to wherever the target lives now. Protocol-relative `//host` is
+ * rejected: it would silently leave the site.
+ */ function safeLinkUrl(url) {
+    if (/^\/(?!\/)/.test(url)) return url;
+    if (isMarkdownLinkReference(url)) return url;
+    return safeUrl(url);
+}
+/**
+ * Image sources take everything a link takes, PLUS a media reference
+ * (AGL-1686).
+ *
+ * Images were the one slot still on absolute-`http(s)`-only, and that was
+ * silently eating two forms the product now produces:
+ *
+ * 1. `media:{scope}/{mediaId}` — what "Browse media" stores everywhere else
+ *    (AGL-1215). The reference names the asset and lets the renderer decide
+ *    how to fetch it, which is the only form that survives a folder move, a
+ *    replace, a route change, and a component shared across sites.
+ * 2. A site-relative `/api/media/cdn/…` or `/images/hero.png`. The visual
+ *    editor's own `isValidImageUrl` accepts these (AGL-1645) and
+ *    `safeLinkUrl` always has — so the parser was the one place that
+ *    disagreed, and it disagreed by DROPPING the whole block. An image with
+ *    an unparseable src emits no block at all, so the failure was not a
+ *    broken-image icon or a console error; the picture simply was not there.
+ *
+ * A malformed reference is still refused. `parseMediaRef` is the same grammar
+ * `formatMediaRef` mints against, so `media:` junk an author typed never
+ * becomes a block whose src no renderer can resolve — the parse boundary
+ * keeps the promise `resolveMediaSrc` makes on the other side.
+ *
+ * Protocol-relative stays refused here exactly as it is for links.
+ *
+ * It takes two things LESS than a link. A link REFERENCE (AGL-3118) names a
+ * page, not a file, so no renderer has a picture to fetch for one; kept, it
+ * would reach an `<img src="entry:…">`.
+ *
+ * And `http:` (AGL-1713). An image is fetched the moment the page renders; a
+ * link is followed by the reader's
+ * choice, past an interstitial the browser puts up. So an `http:` image on our
+ * TLS pages is mixed content that every current browser blocks outright — the
+ * permissive form never rendered a picture, it only moved the failure from
+ * authoring time to the viewer, and stored a src that is a CSP violation
+ * waiting for AGL-1702 to enforce. Refusing it here reports at authoring time
+ * through `isSupportedImageSrc`, which the editor and the besigner picker both
+ * validate against. This is the same asymmetry AGL-1701 struck between
+ * `SAFE_SRC` and `SAFE_HREF` on the published marketplace node, and the same
+ * reason it left `homepageUrl`/`repositoryUrl` as any-https.
+ */ function safeImageUrl(url) {
+    if (isMediaRef(url)) return parseMediaRef(url) ? url : null;
+    if (/^http:\/\//i.test(url)) return null;
+    if (isMarkdownLinkReference(url)) return null;
+    return safeLinkUrl(url);
+}
+/**
+ * True for hrefs the parser emitted as site-relative (start with `/`) AND that
+ * a client router can actually settle on.
+ *
+ * `/api/…` is excluded because those paths serve FILES, not pages —
+ * `/api/media/cdn/{scope}/{id}` is the download URL every media reference
+ * resolves to, and it is what "Browse media" hands an author who links a PDF
+ * or a logo kit. Routed through `AppLink` the click starts a client-side
+ * navigation that can never complete: the response is an attachment, so the
+ * router mounts its navigation-pending overlay and waits forever.
+ *
+ * The tell is a page trapped behind a spinner, NOT a failed download — the
+ * browser fetches the attachment underneath the overlay, so the file lands in
+ * Downloads while the site sits there looking broken. That mismatch sends you
+ * hunting the media endpoint, which answers `200` with a correct
+ * `Content-Disposition: attachment` every time.
+ *
+ * Both callers use this purely to choose `AppLink` vs a plain anchor, so
+ * narrowing it here fixes markdown bodies and collection item links together.
+ */ export function isInternalMarkdownHref(href) {
+    return /^\/(?!\/)/.test(href) && !/^\/api\//.test(href);
+}
+/**
+ * What one parsed link renders as (AGL-3118), for every markdown-lite
+ * renderer on a site: the Markdown element, the entry body and the legacy
+ * article surface.
+ *
+ * A link REFERENCE resolves against the routing map element links use, so a
+ * link in a post follows its target through a rename exactly as a button
+ * does, and a target the map does not have (unpublished, deleted, or never
+ * asked for) renders as the link's text — never as an anchor whose href is
+ * the stored reference. Every other href is the one the parser kept.
+ *
+ * An editing surface withholds every href, so there the only question is
+ * whether a link is drawn at all: a reference the map KNOWS is gone reads as
+ * the text the published page will show, and one the map cannot judge yet —
+ * nothing of its kind has loaded — keeps the link look, for the reason
+ * `isScreenLinkBroken` gives.
+ */ export function resolveMarkdownLink(href, context = {}) {
+    var _context_screens;
+    const screens = (_context_screens = context.screens) != null ? _context_screens : undefined;
+    const reference = isMarkdownLinkReference(href);
+    const resolved = reference ? resolveScreenHref(screens, href) : href;
+    if (context.suppressNavigation) {
+        const gone = reference && resolved === undefined && screenRoutesAnswerFor(screens, href);
+        return gone ? {
+            kind: 'text'
+        } : {
+            kind: 'inert'
+        };
+    }
+    if (resolved === undefined) return {
+        kind: 'text'
+    };
+    return isInternalMarkdownHref(resolved) ? {
+        kind: 'internal',
+        href: resolved
+    } : {
+        kind: 'external',
+        href: resolved
+    };
+}
+/**
+ * Appends plain text, merging into a trailing text inline so the emitted
+ * model is canonical (no adjacent text runs). Canonical inlines are what
+ * makes `serializeMarkdownLite` a true inverse: a degraded link squeezed
+ * between two text gaps re-parses to the same single text inline (AGL-582).
+ */ function pushText(inlines, text) {
+    if (!text) return;
+    const last = inlines[inlines.length - 1];
+    if ((last == null ? void 0 : last.type) === 'text') last.text += text;
+    else inlines.push({
+        type: 'text',
+        text
+    });
+}
+export function parseMarkdownInlines(text) {
+    const inlines = [];
+    let cursor = 0;
+    for (const match of text.matchAll(INLINE_PATTERN)){
+        var _match_index;
+        const index = (_match_index = match.index) != null ? _match_index : 0;
+        if (index > cursor) {
+            pushText(inlines, text.slice(cursor, index));
+        }
+        if (match[2] != null) {
+            inlines.push({
+                type: 'bold',
+                text: match[2]
+            });
+        } else if (match[4] != null) {
+            inlines.push({
+                type: 'italic',
+                text: match[4]
+            });
+        } else if (match[6] != null) {
+            const href = safeLinkUrl(match[7]);
+            if (href) inlines.push({
+                type: 'link',
+                text: match[6],
+                href
+            });
+            else pushText(inlines, match[6]);
+        }
+        cursor = index + match[0].length;
+    }
+    if (cursor < text.length) {
+        pushText(inlines, text.slice(cursor));
+    }
+    return inlines;
+}
+/**
+ * An ATX heading at ANY of markdown's six levels (AGL-1082). The dialect only
+ * RENDERS two, but it must not mistake the other four for prose: matching just
+ * `#{2,3}` made `# Title` — how essentially every repo README opens — fall
+ * through to a paragraph carrying a literal `#`, silently, in every renderer.
+ */ const HEADING_PATTERN = /^(#{1,6})\s+(.*)$/;
+/**
+ * Clamps an ATX level onto the two the block union carries. `#` promotes to
+ * the top rendered level and `####`+ demote to the bottom one, so an out-of-
+ * range heading degrades to the NEAREST heading rather than to prose — the
+ * same lossy-but-visible degradation the dialect already applies to a `*`
+ * inside a bold run. Deliberately NOT widening `level` to `1 | 2 | 3`: every
+ * renderer reads it as `level === 2 ? h2 : h3`, so a third value would type-
+ * check clean and silently render an h1 as an h3 in six places. This also
+ * makes the markdown path agree with the HTML-paste path, which has always
+ * mapped `<h1>` to a level-2 heading.
+ */ function clampHeadingLevel(hashes) {
+    return hashes <= 2 ? 2 : 3;
+}
+/** ```` ``` ```` or longer, optionally naming a language. */ const FENCE_PATTERN = /^`{3,}\s*([^\s`]*)\s*$/;
+/** A bullet-list marker: `- ` or `* `. */ const BULLET_ITEM_PATTERN = /^[-*]\s+/;
+/**
+ * An ordered-list marker (AGL-1320): `1. ` or `1) `, capped at nine digits
+ * like CommonMark so a stray year cannot become an absurd `start`. The
+ * trailing `\s+` is load-bearing twice over: it keeps `1.no space` prose, and
+ * it makes an EMPTY item impossible, which is the other half of CommonMark's
+ * interrupt rule (a bare `1.` may not interrupt a paragraph either).
+ */ const ORDERED_ITEM_PATTERN = /^(\d{1,9})[.)]\s+/;
+/** A delimiter cell of a GFM table's second row: `---`, `:--`, `:-:`, `--:`. */ const DELIMITER_CELL = /^:?-+:?$/;
+/** Splits a table row on `|`, dropping the optional outer pipes. */ function splitTableRow(line) {
+    let text = line.trim();
+    if (text.startsWith('|')) text = text.slice(1);
+    if (text.endsWith('|')) text = text.slice(0, -1);
+    return text.split('|').map((cell)=>cell.trim());
+}
+function alignOfDelimiter(cell) {
+    const left = cell.startsWith(':');
+    const right = cell.endsWith(':');
+    if (left && right) return 'center';
+    return right ? 'right' : 'left';
+}
+/**
+ * A pipe table when the chunk's SECOND line is all delimiter cells — the
+ * same rule GFM uses, and the reason a paragraph mentioning `a | b` is
+ * still a paragraph. Cells are squared off to the header's width: ragged
+ * rows pad with empty cells and overflow is dropped, so the model the
+ * serializer writes back re-parses to itself.
+ */ function parseTable(lines) {
+    const [headerLine, delimiterLine] = lines;
+    if (!headerLine || !delimiterLine || !headerLine.includes('|')) return null;
+    const delimiters = splitTableRow(delimiterLine);
+    if (!delimiters.every((cell)=>DELIMITER_CELL.test(cell))) return null;
+    const header = splitTableRow(headerLine).map(parseMarkdownInlines);
+    const columns = header.length;
+    const squared = (cells)=>Array.from({
+            length: columns
+        }, (_, index)=>{
+            var _cells_index;
+            return parseMarkdownInlines((_cells_index = cells[index]) != null ? _cells_index : '');
+        });
+    return {
+        type: 'table',
+        align: Array.from({
+            length: columns
+        }, (_, index)=>{
+            var _delimiters_index;
+            return alignOfDelimiter((_delimiters_index = delimiters[index]) != null ? _delimiters_index : '---');
+        }),
+        header,
+        rows: lines.slice(2).map((line)=>squared(splitTableRow(line)))
+    };
+}
+/**
+ * Where a list begins, and which one (AGL-1320).
+ *
+ * `interrupting` is true when prose of the SAME chunk is already pending —
+ * i.e. this line would break a paragraph in two. CommonMark's rule, adopted
+ * verbatim: bullets may interrupt a paragraph freely, an ordered list only
+ * when it starts at 1. That is what keeps prose reading `1997. A good year
+ * for the web.` prose, while `…that includes:` followed by `1.`/`2.` becomes
+ * the enumerated list a statute describes. At the head of a chunk nothing is
+ * being interrupted, so any start number opens a list and a counter-notice
+ * resuming at `7.` still counts from seven.
+ */ function listStartOf(line, interrupting) {
+    if (BULLET_ITEM_PATTERN.test(line)) return {
+        kind: 'list',
+        start: 0
+    };
+    const ordered = ORDERED_ITEM_PATTERN.exec(line);
+    if (!ordered) return null;
+    const start = Number(ordered[1]);
+    if (interrupting && start !== 1) return null;
+    return {
+        kind: 'orderedList',
+        start
+    };
+}
+/**
+ * One blank-line-delimited chunk of non-fenced source, as blocks.
+ *
+ * Usually one block — but a chunk splits at a list (AGL-1320), because the
+ * shape legal and instructional prose reaches for most is an introducing line
+ * with its items directly beneath, no blank line between. A list runs to the
+ * first line that is not an item; whatever follows starts a fresh paragraph,
+ * which a later list may interrupt in turn. The serializer writes the pieces
+ * back as separate blank-line-delimited chunks, so the split round-trips.
+ */ function parseChunk(chunk) {
+    const trimmed = chunk.trim();
+    if (!trimmed) return [];
+    const image = /^!\[([^\]]*)\]\(([^)\s]+)\)$/.exec(trimmed);
+    if (image) {
+        const src = safeImageUrl(image[2]);
+        return src ? [
+            {
+                type: 'image',
+                src,
+                alt: image[1]
+            }
+        ] : [];
+    }
+    const heading = HEADING_PATTERN.exec(trimmed);
+    if (heading) {
+        return [
+            {
+                type: 'heading',
+                level: clampHeadingLevel(heading[1].length),
+                inlines: parseMarkdownInlines(heading[2])
+            }
+        ];
+    }
+    const lines = trimmed.split('\n');
+    const table = parseTable(lines);
+    if (table) return [
+        table
+    ];
+    // A quote when EVERY line of the chunk is `>`-prefixed — a paragraph merely
+    // mentioning `>` stays a paragraph, and a quote does NOT interrupt prose the
+    // way a list does (`> ` is far rarer mid-paragraph than a numbered step, and
+    // the all-lines rule is the cheaper guarantee). Fenced code never reaches
+    // here (fences are cut out before chunking), so a `> ` inside a snippet is
+    // snippet text, not a quote (AGL-1315).
+    if (lines.every((line)=>/^>(\s|$)/.test(line.trim()))) {
+        const text = lines.map((line)=>line.trim().replace(/^>\s?/, '')).filter(Boolean).join(' ');
+        return [
+            {
+                type: 'quote',
+                inlines: parseMarkdownInlines(text)
+            }
+        ];
+    }
+    const blocks = [];
+    // Prose lines are buffered RAW and joined with spaces, the way a multi-line
+    // paragraph has always read.
+    let prose = [];
+    const flushProse = ()=>{
+        if (prose.length) {
+            blocks.push({
+                type: 'paragraph',
+                inlines: parseMarkdownInlines(prose.join(' '))
+            });
+        }
+        prose = [];
+    };
+    for(let index = 0; index < lines.length; index++){
+        var _lines_index;
+        const line = ((_lines_index = lines[index]) != null ? _lines_index : '').trim();
+        const list = listStartOf(line, prose.length > 0);
+        if (!list) {
+            var _lines_index1;
+            prose.push((_lines_index1 = lines[index]) != null ? _lines_index1 : '');
+            continue;
+        }
+        flushProse();
+        const pattern = list.kind === 'list' ? BULLET_ITEM_PATTERN : ORDERED_ITEM_PATTERN;
+        const items = [];
+        // The run ends at the first line that is not an item of THIS kind, so a
+        // bullet closes a numbered run and vice versa. Only the FIRST ordered
+        // marker is read, which is why a source numbered `1. 1. 1.` renumbers on
+        // the way out.
+        while(index < lines.length){
+            var _lines_index2;
+            const item = ((_lines_index2 = lines[index]) != null ? _lines_index2 : '').trim();
+            if (!pattern.test(item)) break;
+            items.push(parseMarkdownInlines(item.replace(pattern, '')));
+            index++;
+        }
+        index--;
+        blocks.push(list.kind === 'list' ? {
+            type: 'list',
+            items
+        } : {
+            type: 'orderedList',
+            start: list.start,
+            items
+        });
+    }
+    flushProse();
+    return blocks;
+}
+/**
+ * Blocks are blank-line separated, EXCEPT inside a ``` fence — a code
+ * block owns its blank lines, so the scan is line-driven rather than a
+ * split on `\n{2,}` (AGL-974). An unterminated fence runs to the end of
+ * the document, which is what a README truncated mid-snippet needs.
+ */ export function parseMarkdownLite(body) {
+    const blocks = [];
+    const lines = body.split('\n');
+    let pending = [];
+    const flush = ()=>{
+        // A chunk yields MORE than one block when a list interrupts its prose
+        // (AGL-1320) — and none at all when it holds nothing renderable.
+        if (pending.length) blocks.push(...parseChunk(pending.join('\n')));
+        pending = [];
+    };
+    for(let index = 0; index < lines.length; index++){
+        var _lines_index;
+        const line = (_lines_index = lines[index]) != null ? _lines_index : '';
+        const fence = FENCE_PATTERN.exec(line.trim());
+        if (fence) {
+            var _lines_index1, _fence_;
+            var _text_, _text_1;
+            flush();
+            const text = [];
+            while(++index < lines.length && !FENCE_PATTERN.test(((_lines_index1 = lines[index]) != null ? _lines_index1 : '').trim())){
+                var _lines_index2;
+                text.push((_lines_index2 = lines[index]) != null ? _lines_index2 : '');
+            }
+            // Blank edges are the fence's own padding, not part of the snippet.
+            while(text.length && !((_text_ = text[0]) == null ? void 0 : _text_.trim()))text.shift();
+            while(text.length && !((_text_1 = text[text.length - 1]) == null ? void 0 : _text_1.trim()))text.pop();
+            blocks.push({
+                type: 'code',
+                lang: (_fence_ = fence[1]) != null ? _fence_ : '',
+                text: text.join('\n')
+            });
+            continue;
+        }
+        if (line.trim()) pending.push(line);
+        else flush();
+    }
+    flush();
+    return blocks;
+}
+/** A link or an image in markdown-lite source: bang, text, target. */ const SOURCE_LINK_PATTERN = /(!?)\[([^\]]*)\]\(([^)\s]+)\)/g;
+/**
+ * Markdown-lite SOURCE with its link references resolved (AGL-3118), for a
+ * reader that hands the source on instead of rendering it — the Markdown twin
+ * of a page, which an agent follows links out of.
+ *
+ * `resolve` answers a reference with the URL to write in its place, or with
+ * `undefined` for a target that is gone, and that link becomes its text
+ * alone: a reference no reader can follow is worse than no link at all. An
+ * image whose source is a reference becomes its alt text, because the parser
+ * draws no image for one.
+ *
+ * Everything else stays exactly as written, and fenced code is not touched —
+ * a reference quoted in a snippet is the snippet's text, as the parser has it.
+ */ export function resolveMarkdownSourceLinks(source, resolve) {
+    if (!source.includes('](')) return source;
+    let fenced = false;
+    return source.split('\n').map((line)=>{
+        if (FENCE_PATTERN.test(line.trim())) {
+            fenced = !fenced;
+            return line;
+        }
+        if (fenced || !line.includes('](')) return line;
+        return line.replace(SOURCE_LINK_PATTERN, (match, bang, text, href)=>{
+            if (!isMarkdownLinkReference(href)) return match;
+            const target = bang ? undefined : resolve(href);
+            // A URL cannot close the parentheses it sits in or break at a space.
+            return target ? `[${text}](${target.replace(/\)/g, '%29').replace(/\s/g, '%20')})` : text;
+        });
+    }).join('\n');
+}
+/**
+ * The plain text an inline run reads as — the words with the emphasis and
+ * link syntax removed. What a heading contributes to an anchor slug and to a
+ * table-of-contents label (AGL-1162), where `## The **fine** print` has to
+ * become "The fine print" and `the-fine-print`, not two of either.
+ */ export function markdownInlinesToText(inlines) {
+    return inlines.map((inline)=>inline.text).join('');
+}
+/**
+ * Anchor id for one heading's text (AGL-1162).
+ *
+ * Deterministic by construction — the same words always produce the same id,
+ * which is the whole point: a legal page's true source is a markdown file
+ * elsewhere, and re-pasting it must not silently break every link that ever
+ * pointed into it. Accents fold to their base letter (NFKD then drop the
+ * combining marks) so `Résumé` and `Resume` are the same anchor rather than
+ * one of them being an unreadable percent-encoded id.
+ *
+ * A heading of nothing but punctuation or non-Latin script slugifies to
+ * empty; those get `SLUG_FALLBACK` here and are told apart by the numbering
+ * in {@link collectMarkdownHeadings}, because an id is required for the link
+ * to work at all and no id is worse than a dull one.
+ */ export const SLUG_FALLBACK = 'section';
+export function slugifyHeading(text) {
+    return text.normalize('NFKD')// Combining diacritics left behind by the decomposition above.
+    .replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || SLUG_FALLBACK;
+}
+/**
+ * Every heading in a parsed document, with a unique anchor slug (AGL-1162).
+ *
+ * Duplicates take a `-2`, `-3`, … suffix in document order, and the loop
+ * re-checks the suffixed candidate: a document holding two `## Notice`
+ * headings AND a literal `## Notice 2` must not hand the same id to two
+ * elements, which is exactly what a plain counter would do.
+ *
+ * Deliberately NOT a widening of the `MarkdownBlock` union. The union is
+ * rendered exhaustively in six places, so a slug carried on the heading
+ * block would have to be produced by every writer of that union — including
+ * the visual editor's serializer, which round-trips through markdown source
+ * that has nowhere to put one. Derived here instead, from the same parse the
+ * renderer already has, so the markdown text stays the only source of truth.
+ */ export function collectMarkdownHeadings(blocks) {
+    const headings = [];
+    const used = new Set();
+    blocks.forEach((block, index)=>{
+        if (block.type !== 'heading') return;
+        const text = markdownInlinesToText(block.inlines).trim();
+        const base = slugifyHeading(text);
+        let slug = base;
+        let suffix = 1;
+        while(used.has(slug)){
+            suffix += 1;
+            slug = `${base}-${suffix}`;
+        }
+        used.add(slug);
+        headings.push({
+            level: block.level,
+            text,
+            slug,
+            index
+        });
+    });
+    return headings;
+}
+/**
+ * The same headings keyed by block index, which is the shape every renderer
+ * actually wants (AGL-1162).
+ *
+ * A renderer maps over `blocks` and needs the slug for the block in hand;
+ * {@link collectMarkdownHeadings} returns a list, so each of them had to
+ * rebuild this map. There were six markdown renderers and one of them did —
+ * five published headings a table of contents could never link to, and the
+ * one that worked did it with a private `useMemo` nobody else could reach.
+ * Living here means a new renderer gets the numbering, the fallback and the
+ * duplicate-suffix rules for free rather than approximating them.
+ */ export function markdownHeadingSlugs(blocks) {
+    const map = {};
+    for (const heading of collectMarkdownHeadings(blocks)){
+        map[heading.index] = heading.slug;
+    }
+    return map;
+}
+/**
+ * How far below a heading's anchor the viewport stops (AGL-1162) — enough to
+ * clear a sticky site header, so a `#slug` link does not land with the
+ * heading hidden underneath the nav. Shared so the published page, the entry
+ * body and the console preview all scroll to the same place.
+ */ export const HEADING_ANCHOR_SCROLL_MARGIN = 96;
+/** Newlines cannot exist inside an inline run — flatten them to a space. */ const flattenInlineText = (text)=>text.replace(/\s*\n+\s*/g, ' ');
+/**
+ * Serializes inlines back to markdown-lite source (AGL-582). Characters an
+ * inline run cannot represent (the dialect has NO escapes) are dropped:
+ * `*` inside bold/italic, `]` in link text/alt, `)` or whitespace in URLs.
+ * Parser-emitted inlines never contain them, so for those this is exact.
+ */ export function serializeMarkdownInlines(inlines) {
+    let out = '';
+    for (const inline of inlines){
+        if (inline.type === 'bold' || inline.type === 'italic') {
+            const text = flattenInlineText(inline.text).replace(/\*/g, '');
+            if (!text) continue;
+            out += inline.type === 'bold' ? `**${text}**` : `*${text}*`;
+        } else if (inline.type === 'link') {
+            const text = flattenInlineText(inline.text).replace(/\]/g, '');
+            const href = inline.href.replace(/[)\s]/g, '');
+            out += text && href ? `[${text}](${href})` : text;
+        } else {
+            out += flattenInlineText(inline.text);
+        }
+    }
+    return out;
+}
+/**
+ * Inverse of `parseMarkdownLite` — the WYSIWYG round-trip contract
+ * (AGL-582): for any parser-produced model, the serialized string re-parses
+ * to a deep-equal model, and serializing is stable (a second
+ * parse→serialize round-trip returns the identical string). Editor-produced
+ * models are additionally NORMALIZED the same way the parser would: blocks
+ * and list items that would parse to nothing (empty text) are omitted, and
+ * block lines are edge-trimmed. Entry bodies stay markdown-lite strings in
+ * Firestore — this is the only writer the visual editor goes through.
+ *
+ * Every block is written as its own chunk, separated by a BLANK line, which
+ * is what holds the invariant now that a list may interrupt a paragraph
+ * (AGL-1320): `intro:` + `1. a` re-parses to the same paragraph + list pair
+ * whether or not the author left a blank line between them. The blank line is
+ * therefore load-bearing, not cosmetic: writing the two chunks adjacent would
+ * re-parse correctly today only by luck of the interrupt rule.
+ */ export function serializeMarkdownLite(blocks) {
+    const chunks = [];
+    for (const block of blocks){
+        if (block.type === 'image') {
+            const src = block.src.replace(/[)\s]/g, '');
+            const alt = flattenInlineText(block.alt).replace(/\]/g, '');
+            if (src) chunks.push(`![${alt}](${src})`);
+            continue;
+        }
+        if (block.type === 'list') {
+            const lines = block.items.map((item)=>serializeMarkdownInlines(item).trim()).filter(Boolean).map((line)=>`- ${line}`);
+            if (lines.length) chunks.push(lines.join('\n'));
+            continue;
+        }
+        if (block.type === 'orderedList') {
+            // Markers are RE-NUMBERED from `start` (AGL-1320) rather than written
+            // back verbatim: the parser only reads the first one, so contiguous
+            // markers are the single form that re-parses to this exact model.
+            // A missing/absurd start falls back to 1, the way a hand-written list
+            // reads anyway.
+            const start = Number.isFinite(block.start) ? Math.max(0, Math.trunc(block.start)) : 1;
+            const lines = block.items.map((item)=>serializeMarkdownInlines(item).trim()).filter(Boolean).map((line, index)=>`${start + index}. ${line}`);
+            if (lines.length) chunks.push(lines.join('\n'));
+            continue;
+        }
+        if (block.type === 'code') {
+            // The fence is the only delimiter the dialect has, so a fence INSIDE
+            // the snippet would end it early — those backticks drop, the same way
+            // an unrepresentable `*` drops from a bold run.
+            const text = block.text.replace(/^(\s*)`{3,}/gm, '$1').replace(/^(?:[ \t]*\n)+/, '').replace(/(?:\n[ \t]*)+$/, '');
+            const lang = block.lang.replace(/[^\w+#.-]/g, '');
+            chunks.push([
+                `\`\`\`${lang}`,
+                ...text ? [
+                    text
+                ] : [],
+                '```'
+            ].join('\n'));
+            continue;
+        }
+        if (block.type === 'table') {
+            // `|` separates cells and there are no escapes, so a pipe inside a
+            // cell drops. Empty cells are kept — they are meaningful in a table.
+            const row = (cells)=>`| ${cells.map((cell)=>serializeMarkdownInlines(cell).replace(/\|/g, '').trim()).join(' | ')} |`;
+            if (!block.header.length) continue;
+            const delimiters = block.header.map((_, index)=>{
+                var _block_align_index;
+                const align = (_block_align_index = block.align[index]) != null ? _block_align_index : 'left';
+                return align === 'center' ? ':-:' : align === 'right' ? '--:' : '---';
+            });
+            chunks.push([
+                row(block.header),
+                `| ${delimiters.join(' | ')} |`,
+                // Squared off to the header: the parser reads it back that way,
+                // so writing anything else would not round-trip.
+                ...block.rows.map((cells)=>row(Array.from({
+                        length: block.header.length
+                    }, (_, index)=>{
+                        var _cells_index;
+                        return (_cells_index = cells[index]) != null ? _cells_index : [];
+                    })))
+            ].join('\n'));
+            continue;
+        }
+        const line = serializeMarkdownInlines(block.inlines).trim();
+        if (!line) continue;
+        chunks.push(block.type === 'heading' ? `${'#'.repeat(block.level)} ${line}` : block.type === 'quote' ? `> ${line}` : line);
+    }
+    return chunks.join('\n\n');
+}
+
+//# sourceMappingURL=markdown-lite.js.map