@dogsbay/format-dogsbay-md 0.2.0-beta.13 → 0.2.0-beta.130

package/dist/code-regions.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Code-region walker — THE fence grammar shared by every tool that must
+ * treat code specially: the build preprocessor masks Minja openers
+ * inside code so template examples never evaluate, the workspace
+ * indexer blanks code so `{% include %}` examples never count as real
+ * includes, and the refactor commands edit only prose so code samples
+ * are never rewritten. One implementation, so none of them can drift.
+ *
+ * Fence rules (CommonMark): a fence opens with ``` or ~~~ (3+ chars,
+ * info string allowed) and closes only on a line of the SAME character
+ * with AT LEAST the opener's length and nothing but whitespace after —
+ * the serializer emits escalated fences (```` around content containing
+ * ```), so honoring the length rule is load-bearing. Fence-looking
+ * lines inside an open fence that don't close it are code content.
+ */
+type LineKind = "prose" | "fence" | "code";
+/** Context passed to a code transform: which fence the line belongs to. */
+export interface CodeRegionContext {
+    /**
+     * Fence info string (e.g. `yaml {minja}`). For inline code spans:
+     * the markdown-it-attrs group immediately following the closing
+     * backticks when present (e.g. `{minja}` for `` `x`{minja} ``),
+     * empty otherwise — so `isMinjaProcessedFence` grades fences and
+     * marked inline spans with the same predicate.
+     */
+    fenceInfo: string;
+}
+/**
+ * Transform CODE content: every line inside a fence, and the inner
+ * content of inline code spans on prose lines (backticks kept). Fence
+ * marker lines themselves are untouched.
+ *
+ * `transformInlineAttrs` (optional) rewrites the attr group of an
+ * inline span at re-emission — return `""` to drop it. Only inline
+ * spans see it; fence info strings are never routed through it.
+ */
+/**
+ * Line-by-line fence tracker on THE shared grammar — for tools that must
+ * walk a document themselves (the remote-include inliner) instead of
+ * transforming regions. A locally re-implemented open/close regex pair
+ * drifted immediately: it missed the deflist-hosted `:   ```` opener the
+ * shared grammar just gained, took the indented closer for an opener,
+ * and re-created the exact phantom-fence inversion it was fixing
+ * (issue #039 review).
+ *
+ * step(line) returns what the line IS: "fence" (an opener or closer),
+ * "code" (content of an open fence), or "prose". open() reports the
+ * state AFTER the last step, so an opener steps "fence" with
+ * open()===true and its closer steps "fence" with open()===false.
+ */
+export declare function createFenceTracker(): {
+    step(line: string): LineKind;
+    open(): boolean;
+};
+/**
+ * Transform only fence OPENING lines' info strings, on the same shared
+ * grammar — a fence-looking line inside an open fence is code content
+ * and is never touched. Used to strip the spent `{minja}` marker after
+ * the terminal Minja render (a fence marker that survives into the
+ * mirror leaks into serializers that round-trip fence info verbatim —
+ * the Obsidian vault showed literal ```` ```yaml {minja} ````).
+ */
+export declare function transformFenceInfo(source: string, transform: (info: string) => string): string;
+export declare function transformCodeRegions(source: string, transform: (codeText: string, ctx: CodeRegionContext) => string, transformInlineAttrs?: (attrs: string) => string): string;
+/**
+ * The inverse walk: transform PROSE lines (outside fences), leaving
+ * fenced content and the fence lines untouched. Used by refactor
+ * commands that rewrite markdown structure line-wise (heading shifts,
+ * section splits) — a `# heading` inside a code example must never be
+ * treated as structure.
+ */
+export declare function transformProseLines(source: string, transform: (line: string, lineIndex: number) => string): string;
+/**
+ * Transform PROSE TEXT SEGMENTS: prose lines with their inline code
+ * spans protected (the transform sees only the non-code stretches of
+ * each prose line). This is the write-side counterpart of
+ * transformCodeRegions — refactor commands rewrite references through
+ * it so `[x](old.md)` or `{{ key }}` inside examples survive verbatim.
+ */
+export declare function transformProseSegments(source: string, transform: (proseText: string) => string): string;
+/**
+ * Fence state BEFORE each line: `openBefore[i]` is true when line i
+ * starts inside an unclosed fence. One extra trailing entry gives the
+ * state after the last line. Lets line-range refactors check "does
+ * this range start or end mid-fence" with the same grammar.
+ */
+export declare function fenceOpenBefore(source: string): boolean[];
+export {};

package/dist/code-regions.js

@@ -0,0 +1,214 @@
+/**
+ * Code-region walker — THE fence grammar shared by every tool that must
+ * treat code specially: the build preprocessor masks Minja openers
+ * inside code so template examples never evaluate, the workspace
+ * indexer blanks code so `{% include %}` examples never count as real
+ * includes, and the refactor commands edit only prose so code samples
+ * are never rewritten. One implementation, so none of them can drift.
+ *
+ * Fence rules (CommonMark): a fence opens with ``` or ~~~ (3+ chars,
+ * info string allowed) and closes only on a line of the SAME character
+ * with AT LEAST the opener's length and nothing but whitespace after —
+ * the serializer emits escalated fences (```` around content containing
+ * ```), so honoring the length rule is load-bearing. Fence-looking
+ * lines inside an open fence that don't close it are code content.
+ */
+// A fence may open as DEFLIST DEFINITION content with the definition
+// marker glued to the opener (`:   ```` — the adoc engine emits this when
+// a dlist definition's first block is a listing; markdown-it-deflist also
+// accepts `~` as the marker). markdown-it opens a fence there, so this
+// grammar must too: without the prefix the walker took the CLOSER for an
+// opener and inverted — prose after the dlist was masked as code and its
+// `{{ attr }}` refs never resolved (virt-cluster-resource-requirements,
+// the #030 residual class). The marker takes 1–3 spaces: at 4+ markdown-it
+// reads an indented code block, not a fence. The info capture excludes a
+// trailing `\r` so CRLF text grades identically (`.` can't match `\r`,
+// which silently disabled the whole grammar on CRLF files).
+//
+// KNOWN bounded divergence: markdown-it only forms a deflist when a term
+// paragraph precedes; at document start or right after a heading/list a
+// `:   ```` line is plain text. The walker opens (and, via the dedent
+// rule, promptly closes) a fence there — a line-local grammar cannot see
+// the term context. The divergence is bounded to the pseudo-fence's own
+// region; the tail re-aligns at the first dedent.
+const OPEN_RE = /^\s*(?:[:~][ \t]{1,3})?(`{3,}|~{3,})(.*?)\r?$/;
+const CLOSE_RE = /^\s*(`{3,}|~{3,})\s*$/;
+const stepFence = (state, line) => {
+    if (state.open) {
+        // A deflist-hosted fence ends when a non-blank line dedents out of
+        // the definition (indent < 4) — markdown-it terminates the fence
+        // BEFORE reading that line, so reprocess it in closed state: it may
+        // itself open a REAL fence (the col-0 ``` after a dedented deflist
+        // fence swallowed the document tail when taken as a closer — review
+        // finding).
+        if (state.hosted && /^ {0,3}\S/.test(line)) {
+            state.open = false;
+            state.info = "";
+            state.hosted = false;
+            // fall through to closed-state handling for this same line
+        }
+        else {
+            const close = line.match(CLOSE_RE);
+            if (close && close[1][0] === state.marker && close[1].length >= state.length) {
+                state.open = false;
+                state.info = "";
+                state.hosted = false;
+                return "fence";
+            }
+            return "code";
+        }
+    }
+    const open = line.match(OPEN_RE);
+    if (open) {
+        state.open = true;
+        state.marker = open[1][0];
+        state.length = open[1].length;
+        state.info = open[2].trim();
+        state.hosted = /^\s*[:~][ \t]/.test(line);
+        return "fence";
+    }
+    return "prose";
+};
+const newState = () => ({ open: false, marker: "", length: 0, info: "", hosted: false });
+/**
+ * Transform CODE content: every line inside a fence, and the inner
+ * content of inline code spans on prose lines (backticks kept). Fence
+ * marker lines themselves are untouched.
+ *
+ * `transformInlineAttrs` (optional) rewrites the attr group of an
+ * inline span at re-emission — return `""` to drop it. Only inline
+ * spans see it; fence info strings are never routed through it.
+ */
+/**
+ * Line-by-line fence tracker on THE shared grammar — for tools that must
+ * walk a document themselves (the remote-include inliner) instead of
+ * transforming regions. A locally re-implemented open/close regex pair
+ * drifted immediately: it missed the deflist-hosted `:   ```` opener the
+ * shared grammar just gained, took the indented closer for an opener,
+ * and re-created the exact phantom-fence inversion it was fixing
+ * (issue #039 review).
+ *
+ * step(line) returns what the line IS: "fence" (an opener or closer),
+ * "code" (content of an open fence), or "prose". open() reports the
+ * state AFTER the last step, so an opener steps "fence" with
+ * open()===true and its closer steps "fence" with open()===false.
+ */
+export function createFenceTracker() {
+    const state = newState();
+    return {
+        step: (line) => stepFence(state, line),
+        open: () => state.open,
+    };
+}
+/**
+ * Transform only fence OPENING lines' info strings, on the same shared
+ * grammar — a fence-looking line inside an open fence is code content
+ * and is never touched. Used to strip the spent `{minja}` marker after
+ * the terminal Minja render (a fence marker that survives into the
+ * mirror leaks into serializers that round-trip fence info verbatim —
+ * the Obsidian vault showed literal ```` ```yaml {minja} ````).
+ */
+export function transformFenceInfo(source, transform) {
+    const state = newState();
+    return source
+        .split("\n")
+        .map((line) => {
+        const wasOpen = state.open;
+        if (stepFence(state, line) === "fence" && !wasOpen) {
+            // Opening fence: rewrite the info string in place. Untouched info
+            // returns the line BYTE-IDENTICAL (incl. any trailing \r) — this
+            // is a write path on the shared grammar, and rewriting lines the
+            // transform didn't change broke mirror byte-stability (review).
+            const m = line.match(OPEN_RE);
+            if (m) {
+                const runEnd = line.indexOf(m[1]) + m[1].length;
+                const hadCR = line.endsWith("\r");
+                const info = line.substring(runEnd, hadCR ? line.length - 1 : line.length);
+                const newInfo = transform(info);
+                return newInfo === info ? line : line.substring(0, runEnd) + newInfo + (hadCR ? "\r" : "");
+            }
+        }
+        return line;
+    })
+        .join("\n");
+}
+export function transformCodeRegions(source, transform, transformInlineAttrs) {
+    const state = newState();
+    return source
+        .split("\n")
+        .map((line) => {
+        switch (stepFence(state, line)) {
+            case "fence":
+                return line;
+            case "code":
+                return transform(line, { fenceInfo: state.info });
+            default:
+                // An attr group directly after the closing ticks travels as
+                // the region's info string: `` `x`{minja} `` opts the span
+                // into Minja processing exactly like a `{minja}` fence.
+                // Backticks are excluded from the group so a brace group can
+                // never swallow a span opener and shift pairing vs markdown-it.
+                return line.replace(/(`+)([^`]*?)\1(\{[^{}`\n]*\})?/g, (_m, ticks, inner, attrs) => ticks + transform(inner, { fenceInfo: attrs ?? "" }) + ticks +
+                    (attrs === undefined ? "" : transformInlineAttrs ? transformInlineAttrs(attrs) : attrs));
+        }
+    })
+        .join("\n");
+}
+/**
+ * The inverse walk: transform PROSE lines (outside fences), leaving
+ * fenced content and the fence lines untouched. Used by refactor
+ * commands that rewrite markdown structure line-wise (heading shifts,
+ * section splits) — a `# heading` inside a code example must never be
+ * treated as structure.
+ */
+export function transformProseLines(source, transform) {
+    const state = newState();
+    return source
+        .split("\n")
+        .map((line, index) => (stepFence(state, line) === "prose" ? transform(line, index) : line))
+        .join("\n");
+}
+/**
+ * Transform PROSE TEXT SEGMENTS: prose lines with their inline code
+ * spans protected (the transform sees only the non-code stretches of
+ * each prose line). This is the write-side counterpart of
+ * transformCodeRegions — refactor commands rewrite references through
+ * it so `[x](old.md)` or `{{ key }}` inside examples survive verbatim.
+ */
+export function transformProseSegments(source, transform) {
+    const state = newState();
+    return source
+        .split("\n")
+        .map((line) => {
+        if (stepFence(state, line) !== "prose")
+            return line;
+        // Split the line into code spans and prose stretches; transform
+        // only the prose stretches
+        const parts = [];
+        let last = 0;
+        for (const match of line.matchAll(/(`+)[^`]*?\1/g)) {
+            parts.push(transform(line.slice(last, match.index)));
+            parts.push(match[0]);
+            last = match.index + match[0].length;
+        }
+        parts.push(transform(line.slice(last)));
+        return parts.join("");
+    })
+        .join("\n");
+}
+/**
+ * Fence state BEFORE each line: `openBefore[i]` is true when line i
+ * starts inside an unclosed fence. One extra trailing entry gives the
+ * state after the last line. Lets line-range refactors check "does
+ * this range start or end mid-fence" with the same grammar.
+ */
+export function fenceOpenBefore(source) {
+    const state = newState();
+    const states = [];
+    for (const line of source.split("\n")) {
+        states.push(state.open);
+        stepFence(state, line);
+    }
+    states.push(state.open);
+    return states;
+}

package/dist/container-rule.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The `:::name` container block rule: markdown-it-container 4.0.0 (MIT,
+ * Vitaly Puzrin, Alex Kocharin), adapted. Three changes, all in how the
+ * closing line is found:
+ *
+ * 1. A closer may carry an HTML comment, `::: <!-- end note -->`, the way an
+ *    author labels an XML end tag. The comment changes nothing about which
+ *    container closes; it rides on the close token (`info`) so the parser can
+ *    keep it and diagnostics can check the name.
+ * 2. A `:::` line inside a code block does not close the container.
+ *    markdown-it-container scanned raw lines, so a code example showing a
+ *    directive closed the container around it and the rest of the page became
+ *    one code block, with no message. Which lines are code comes from one
+ *    block-level pass over the source with containers off (codeLines).
+ *
+ * 3. Blocks nest by a stack, not by colon count (NESTING below).
+ *
+ * Everything else (indentation, auto-close at the end of the parent) is
+ * markdown-it-container's.
+ *
+ * markdown-it-container's licence:
+ *
+ * Copyright (c) 2015 Vitaly Puzrin, Alex Kocharin.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+import type MarkdownIt from "markdown-it";
+/**
+ * NESTING. A closer with N colons closes the innermost open block opened with exactly N colons,
+ * else the innermost opened with fewer, and any block still open inside it. So every block can close with plain `:::`
+ * (`:::steps` … `:::tabs` … `:::` … `:::`), and today's scaled nesting (`::::steps` … `:::tabs`
+ * … `:::` … `::::`) and the inverse (inner blocks with more colons) read the same. Pandoc's fenced
+ * divs nest the same way. Before the stack, a closer ended the OUTERMOST block it was long
+ * enough for, so a nested block needed more colons on the outer one, and one `:::` could close
+ * several blocks (that case now leaves the outer one open, and the diagnostic says why). "Exactly
+ * N first" keeps the old reading where the author scaled: `::::note` … `:::tip` … `::::` closes the
+ * note (and the tip with it) as before, rather than the tip.
+ *
+ * Only a known directive name opens a block in the scan. An unknown `:::word` is a block only if
+ * it has a closer of its own and is otherwise text (markUnclosedGenericContainers), and the scan
+ * cannot know which, so it does not push one: an unknown block nested at the same colon count
+ * as its parent still needs more colons on the parent. `:::` always opens a block that needs a
+ * closer; a directive with no body is a leaf, `::youtube{#id}` (plugin-block-leaf.ts), so no
+ * opener depends on the line after it.
+ *
+ * VERIFY. The scan reads raw lines, and markdown-it may not read an opener there as one: in raw
+ * HTML, a `$$` math block, a fence that never closes. Where that is depends on where the blocks
+ * around it end, so no pass over the page can say in advance. So after the body is tokenized, every
+ * opener the scan pushed must have opened a block in it; any that did not are left out and the
+ * body is scanned and tokenized again. Counted wrongly, an opener leaves the outer block open to
+ * the end of the page (the rule before the stack lost one closer at most). What a block learns is
+ * kept for the parse, by its opening line: when an outer block retries, the blocks inside it are
+ * tokenized again and start from what they learned, rather than repeating their own retries (which
+ * doubled the work at every level). A learned line can be stale in the new context, so the check
+ * runs both ways: a skipped line that markdown-it did open as a block is pushed again. Retried
+ * lines come out of one budget per parse (a few times the page's lines); past it, the scan stands.
+ */
+export interface ContainerOptions {
+    validate: (params: string, markup: string) => boolean;
+    render?: (tokens: unknown[], idx: number) => string;
+}
+/** Make `name` an opener for the nesting scan (the known directives; not the generic container). */
+export declare function registerOpener(name: string): void;
+export declare function containerRule(md: MarkdownIt, name: string, options: ContainerOptions): void;

package/dist/container-rule.js

@@ -0,0 +1,280 @@
+/**
+ * What may follow a closer's colons: nothing, or spaces and one HTML comment, then spaces. The
+ * comment is not optional inside the group: `[ \t]*(…)?[ \t]*` backtracks quadratically on a long
+ * run of spaces followed by anything else.
+ */
+const CLOSER_TAIL = /^(?:[ \t]*|[ \t]*(<!--(?:(?!-->)[\s\S])*-->)[ \t]*)$/;
+/** state.env keys: the pre-pass that finds the code, and its result. */
+const NO_CONTAINERS = "__dogsbayNoContainers";
+const CODE_LINES = "__dogsbayCodeLines";
+/** state.env keys for VERIFY: the parse's retry budget, and each block's learned openers to skip. */
+const RETRY_BUDGET = "__dogsbayContainerRetries";
+const LEARNED = "__dogsbayContainerNotOpeners";
+/**
+ * The source lines inside a fenced code block, from one block-level pass over the whole source
+ * with containers switched off, made the first time a container needs it and kept in the parse's
+ * env. A `:::` line cannot change where a fence starts or ends (a fence ends only at its own
+ * closing fence or the end of its list item or quote), so the pass agrees with the real parse,
+ * and markdown-it reads fences in quotes, list items and definitions as a line scan does not.
+ * One pass per parse, so the cost is linear however many containers there are or how deep.
+ *
+ * Only a fence that CLOSES counts. With no container to end it, an unclosed fence in the pass runs
+ * to the end of the page, and every closer after it would be code: a ````` ```` ````` fence closed
+ * with three backticks would take the rest of the page into its container. Left out, it ends at
+ * the container's closer, as with markdown-it-container. (Still misread, and no worse than
+ * markdown-it-container: a `:::name` straight after a list item, lazily continuing it in the pass,
+ * so a fence indented four in the container is read in the item.)
+ */
+function codeLines(state) {
+    const env = state.env;
+    const cached = env?.[CODE_LINES];
+    if (cached && cached.src === state.src && cached.md === state.md)
+        return cached.lines;
+    const tokens = [];
+    state.md.block.parse(state.src, state.md, { [NO_CONTAINERS]: true }, tokens);
+    const source = state.src.split(/\r\n|\r|\n/);
+    const lines = new Set();
+    for (const t of tokens) {
+        if (t.type !== "fence" || !t.map || !closesFence(source[t.map[1] - 1], t.markup, t.map[1] - 1 > t.map[0]))
+            continue;
+        // A fence's opening line is not inside it; the lines after it, to its closing fence, are
+        for (let l = t.map[0] + 1; l < t.map[1]; l++)
+            lines.add(l);
+    }
+    if (env)
+        env[CODE_LINES] = { src: state.src, md: state.md, lines };
+    return lines;
+}
+/** Whether `line` (as written, with any `>` and indentation) is the closing fence of a fence opened with `markup`. */
+function closesFence(line, markup, after) {
+    if (!after || line === undefined)
+        return false;
+    const m = /^[ \t>]*(`{3,}|~{3,})[ \t]*$/.exec(line);
+    return m !== null && m[1][0] === markup[0] && m[1].length >= markup.length;
+}
+/** The directive names the scan treats as openers (plugin-containers registers them). */
+const KNOWN_OPENERS = new Set();
+/** Whether the text after an opener's colons starts with a known directive name. */
+function isKnownOpener(rest) {
+    const m = /^\s*([A-Za-z][\w-]*)(?=$|[\s{[])/.exec(rest);
+    return m !== null && KNOWN_OPENERS.has(m[1]);
+}
+/** Make `name` an opener for the nesting scan (the known directives; not the generic container). */
+export function registerOpener(name) {
+    KNOWN_OPENERS.add(name);
+}
+/** Tokens whose lines are not block openers: an opener the scan pushed inside one is wrong (VERIFY). */
+const READ_AS_OTHER = new Set(["paragraph_open", "heading_open", "html_block", "fence", "code_block", "math_block", "hr", "table_open"]);
+/** The openers each block (by opening line) learned to skip in this parse (VERIFY). */
+function learned(state) {
+    const env = state.env;
+    if (!env)
+        return new Map();
+    const kept = env[LEARNED];
+    if (kept && kept.src === state.src)
+        return kept.map;
+    const map = new Map();
+    env[LEARNED] = { src: state.src, map };
+    return map;
+}
+/** The lines left in this parse's retry budget (VERIFY), shared by every block in it. */
+function retryBudget(state) {
+    const env = state.env;
+    const fresh = { lines: 4 * state.bMarks.length + 1000 };
+    if (!env)
+        return fresh;
+    const kept = env[RETRY_BUDGET];
+    if (kept && kept.src === state.src)
+        return kept.budget;
+    env[RETRY_BUDGET] = { src: state.src, budget: fresh };
+    return fresh;
+}
+export function containerRule(md, name, options) {
+    const MARKER = ":".charCodeAt(0);
+    function container(state, startLine, endLine, silent) {
+        const start = state.bMarks[startLine] + state.tShift[startLine];
+        const max = state.eMarks[startLine];
+        if (state.src.charCodeAt(start) !== MARKER)
+            return false;
+        if (state.env?.[NO_CONTAINERS])
+            return false;
+        let pos = start + 1;
+        while (pos <= max && state.src.charCodeAt(pos) === MARKER)
+            pos++;
+        const markerCount = pos - start;
+        if (markerCount < 3)
+            return false;
+        const markup = state.src.slice(start, pos);
+        const params = state.src.slice(pos, max);
+        if (!options.validate(params, markup))
+            return false;
+        if (silent)
+            return true;
+        const oldParent = state.parentType;
+        const oldLineMax = state.lineMax;
+        state.parentType = "container";
+        const tokensBefore = state.tokens.length;
+        // Openers markdown-it did not open, found by an earlier try (VERIFY above)
+        const known = learned(state);
+        const notOpeners = new Set(known.get(startLine));
+        let scan;
+        for (;;) {
+            scan = scanBody(state, startLine, endLine, markerCount, notOpeners);
+            // lazy continuations never run past the closer
+            state.lineMax = scan.nextLine;
+            const open = state.push(`container_${name}_open`, "div", 1);
+            open.markup = markup;
+            open.block = true;
+            open.info = params;
+            open.map = [startLine, scan.nextLine];
+            if (!scan.autoClosed && (scan.skippedCloser !== undefined || scan.legacyCloser !== undefined)) {
+                open.meta = {
+                    ...(open.meta ?? {}),
+                    ...(scan.skippedCloser !== undefined ? { skippedCloser: scan.skippedCloser } : {}),
+                    ...(scan.legacyCloser !== undefined ? { legacyCloser: scan.legacyCloser } : {}),
+                };
+            }
+            state.md.block.tokenize(state, startLine + 1, scan.nextLine);
+            const close = state.push(`container_${name}_close`, "div", -1);
+            close.markup = scan.closeMarkup;
+            close.block = true;
+            close.info = scan.closeComment;
+            // Wrong: a pushed opener's line that markdown-it read as something else. A line it read as
+            // nothing (past markdown-it's nesting limit, where it drops the rest) is not evidence.
+            // Missed: a skipped line markdown-it did open as a block (a learned line, stale here).
+            const pushed = new Set(scan.pushed);
+            const wrong = [];
+            const missed = [];
+            if (pushed.size > 0 || notOpeners.size > 0) {
+                for (let i = tokensBefore + 1; i < state.tokens.length; i++) {
+                    const t = state.tokens[i];
+                    if (!t.map)
+                        continue;
+                    if (READ_AS_OTHER.has(t.type)) {
+                        for (let l = t.map[0]; l < t.map[1]; l++)
+                            if (pushed.delete(l))
+                                wrong.push(l);
+                    }
+                    else if (t.nesting === 1 && t.type.startsWith("container_") && notOpeners.has(t.map[0]))
+                        missed.push(t.map[0]);
+                }
+            }
+            if (wrong.length === 0 && missed.length === 0)
+                break;
+            const budget = retryBudget(state);
+            if (budget.lines < scan.nextLine - startLine) {
+                // Out of budget: this reading stands, with an opener known to be wrong; say so (diagnostics)
+                open.meta = { ...(open.meta ?? {}), unverified: true };
+                break;
+            }
+            budget.lines -= scan.nextLine - startLine;
+            for (const l of wrong)
+                notOpeners.add(l);
+            for (const l of missed)
+                notOpeners.delete(l);
+            state.tokens.length = tokensBefore;
+        }
+        if (notOpeners.size > 0)
+            known.set(startLine, new Set(notOpeners));
+        else
+            known.delete(startLine);
+        state.parentType = oldParent;
+        state.lineMax = oldLineMax;
+        state.line = scan.nextLine + (scan.autoClosed ? 1 : 0);
+        return true;
+    }
+    /** Find where the block opened at `startLine` ends (NESTING above), skipping the `notOpeners` lines as openers. */
+    function scanBody(state, startLine, endLine, markerCount, notOpeners) {
+        let code;
+        let nextLine = startLine;
+        const scan = { nextLine, autoClosed: false, closeMarkup: "", closeComment: "", pushed: [] };
+        // Blocks opened inside this one and not yet closed, innermost last (see NESTING above)
+        // `least` is the fewest colons from the outermost to this one, and `openCount` counts the open
+        // blocks by colons, so a closer that fits none is turned away without walking the stack
+        const inner = [];
+        const openCount = new Map();
+        const truncate = (k) => {
+            for (let j = k; j < inner.length; j++)
+                openCount.set(inner[j].colons, openCount.get(inner[j].colons) - 1);
+            inner.length = k;
+        };
+        for (;;) {
+            nextLine++;
+            // unclosed: closed by the end of the document or of the parent block
+            if (nextLine >= endLine)
+                break;
+            const start = state.bMarks[nextLine] + state.tShift[nextLine];
+            const max = state.eMarks[nextLine];
+            if (start >= max)
+                continue;
+            // a non-empty line indented less than the block ends it (a list item's container)
+            if (state.sCount[nextLine] < state.blkIndent)
+                break;
+            // a block opened deeper (in a list item) ended at a line indented less than its opener
+            while (inner.length > 0 && state.sCount[nextLine] < inner[inner.length - 1].indent)
+                truncate(inner.length - 1);
+            if (state.src.charCodeAt(start) !== MARKER)
+                continue;
+            // openers and closers are indented less than 4 spaces past the block
+            if (state.sCount[nextLine] - state.blkIndent >= 4)
+                continue;
+            let pos = start + 1;
+            while (pos < max && state.src.charCodeAt(pos) === MARKER)
+                pos++;
+            const colons = pos - start;
+            if (colons < 3)
+                continue;
+            const rest = state.src.slice(pos, max);
+            const tail = CLOSER_TAIL.exec(rest);
+            const opener = !tail && isKnownOpener(rest);
+            if (!tail && !opener)
+                continue;
+            // a `:::` in a code example is code
+            if ((code ??= codeLines(state)).has(nextLine)) {
+                if (tail && colons >= markerCount)
+                    scan.skippedCloser ??= nextLine;
+                continue;
+            }
+            if (opener) {
+                if (notOpeners.has(nextLine))
+                    continue;
+                const least = Math.min(colons, inner.length > 0 ? inner[inner.length - 1].least : colons);
+                inner.push({ colons, indent: state.sCount[nextLine], least });
+                openCount.set(colons, (openCount.get(colons) ?? 0) + 1);
+                scan.pushed.push(nextLine);
+                continue;
+            }
+            // Where the rule before the stack (the first closer with enough colons) would have ended this block
+            if (colons >= markerCount)
+                scan.legacyCloser ??= nextLine;
+            // The innermost open block opened with exactly this many colons, else the innermost opened
+            // with fewer; it closes, and any block still open inside it. Index -1 is this block.
+            const closes = (fits) => {
+                for (let k = inner.length - 1; k >= 0; k--)
+                    if (fits(inner[k].colons))
+                        return k;
+                return fits(markerCount) ? -1 : undefined;
+            };
+            const exact = (openCount.get(colons) ?? 0) > 0 || markerCount === colons;
+            const fewer = markerCount < colons || (inner.length > 0 && inner[inner.length - 1].least < colons);
+            const k = exact ? closes((n) => n === colons) : fewer ? closes((n) => n < colons) : undefined;
+            // shorter than every open block: it closes nothing here
+            if (k === undefined)
+                continue;
+            if (k >= 0) {
+                truncate(k);
+                continue;
+            }
+            scan.autoClosed = true;
+            scan.closeMarkup = state.src.slice(start, pos);
+            scan.closeComment = tail?.[1] ?? "";
+            break;
+        }
+        scan.nextLine = nextLine;
+        return scan;
+    }
+    md.block.ruler.before("fence", `container_${name}`, container, { alt: ["paragraph", "reference", "blockquote", "list"] });
+    const render = options.render ?? (() => "");
+    md.renderer.rules[`container_${name}_open`] = render;
+    md.renderer.rules[`container_${name}_close`] = render;
+}