@redocly/recheck 0.14.0 → 2.58.0

package/dist/metrics/statistics.js

@@ -1,56 +0,0 @@
-import { splitSentences } from '../scopes/sentences.js';
-// A "word" is a maximal whitespace-delimited token containing at least one
-// ASCII letter or digit: punctuation-only tokens (a lone "--" or "...")
-// don't count, while hyphenated compounds ("well-known") and contractions
-// ("don't") count as ONE word each. Tokenization is ASCII-only throughout
-// this module (here, the syllable heuristic, and the `characters` count),
-// so scores are meaningful for English prose.
-//
-// Exported deliberately -- there are exactly two consumers, and they must
-// share one implementation: `computeTextStatistics` below (readability
-// formulas) and the `length` scope assertion's `unit: 'words'` measurement
-// (rules/scope/length.ts). If `length` grew its own word-counting regex,
-// its word counts could silently drift from `metric`'s (e.g. a Microsoft
-// preset rule capping alt text at N words would disagree with a readability
-// rule scoring the same text) -- a duplicate here would be a correctness
-// bug, not just repeated code, so this is a shared-utility export, not the
-// "new rule's only consumer" shape a reviewer should otherwise flag (see
-// task-6-resolutions.md item 4).
-export function tokenizeWords(prose) {
-    return prose.split(/\s+/).filter((token) => /[A-Za-z0-9]/.test(token));
-}
-// Syllable heuristic: count vowel groups (/[aeiouy]+/, lowercase); subtract
-// one for a silent trailing 'e' unless the word ends in 'le' ("table");
-// minimum of 1. The token is first reduced to lowercase letters, hyphens,
-// and apostrophes so attached punctuation ("make,") can't defeat the
-// trailing-e check; hyphens/apostrophes are kept because they act as real
-// syllable boundaries ("co-op" is 2 vowel groups, "coop" is 1).
-function countSyllables(word) {
-    const clean = word.toLowerCase().replace(/[^a-z'-]/g, '');
-    const groups = clean.match(/[aeiouy]+/g) ?? [];
-    let count = groups.length;
-    if (clean.endsWith('e') && !clean.endsWith('le'))
-        count -= 1;
-    return Math.max(1, count);
-}
-/**
- * Computes word/sentence/syllable/character/complex-word statistics for a
- * plain prose string. `sentences` is delegated to `scopes/sentences.ts`'s
- * `splitSentences` so the whole codebase shares one sentence-boundary
- * definition.
- */
-export function computeTextStatistics(prose) {
-    const words = tokenizeWords(prose);
-    const sentences = splitSentences(prose).length;
-    const characters = (prose.match(/[A-Za-z0-9]/g) ?? []).length;
-    let syllables = 0;
-    let complexWords = 0;
-    for (const word of words) {
-        const count = countSyllables(word);
-        syllables += count;
-        if (count >= 3)
-            complexWords += 1;
-    }
-    return { words: words.length, sentences, syllables, characters, complexWords };
-}
-//# sourceMappingURL=statistics.js.map

package/dist/metrics/statistics.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"statistics.js","sourceRoot":"","sources":["../../src/metrics/statistics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAqBxD,2EAA2E;AAC3E,wEAAwE;AACxE,0EAA0E;AAC1E,0EAA0E;AAC1E,0EAA0E;AAC1E,8CAA8C;AAC9C,EAAE;AACF,0EAA0E;AAC1E,uEAAuE;AACvE,2EAA2E;AAC3E,yEAAyE;AACzE,yEAAyE;AACzE,4EAA4E;AAC5E,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,iCAAiC;AACjC,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,4EAA4E;AAC5E,wEAAwE;AACxE,0EAA0E;AAC1E,qEAAqE;AACrE,0EAA0E;AAC1E,gEAAgE;AAChE,SAAS,cAAc,CAAC,IAAY;IAClC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC/C,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IAC1B,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,KAAK,IAAI,CAAC,CAAC;IAC7D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAa;IACjD,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IACnC,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IAC/C,MAAM,UAAU,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IAE9D,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;QACnC,SAAS,IAAI,KAAK,CAAC;QACnB,IAAI,KAAK,IAAI,CAAC;YAAE,YAAY,IAAI,CAAC,CAAC;IACpC,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;AACjF,CAAC"}

package/dist/parser/index.d.ts

@@ -1,19 +0,0 @@
-import type { Token, TokenTree } from './types.js';
-export type { Token, TokenTree } from './types.js';
-export interface ParseOptions {
-    markdoc?: boolean;
-    embedded?: boolean;
-}
-export declare function parseMarkdown(content: string, options?: ParseOptions): TokenTree;
-/**
- * Filters the tree's flat token list by type. By default, tokens produced
- * by reparsing an `htmlFlow` block (see `reparseHtmlFlow` above) are
- * EXCLUDED -- matching upstream markdownlint's own `filterByTypes(tokens,
- * types, htmlFlow)` helper, whose `htmlFlow` parameter defaults to falsy.
- * Pass `includeHtmlFlow: true` for rules that explicitly want to see
- * inside HTML blocks too (upstream's MD033/no-inline-html and
- * MD045/no-alt-text opt in this way; see their recheck ports for the same
- * opt-in).
- */
-export declare function filterByTypes(tree: TokenTree, types: readonly string[], includeHtmlFlow?: boolean): Token[];
-//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAInD,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AA+InD,MAAM,WAAW,YAAY;IAI3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAGlB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,SAAS,CAepF;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,eAAe,UAAQ,GACtB,KAAK,EAAE,CAIT"}

package/dist/parser/index.js

@@ -1,174 +0,0 @@
-// Micromark wrapper producing Recheck's public TokenTree.
-// Event-to-tree construction adapted from markdownlint's lib/micromark-parse.mjs
-// (https://github.com/DavidAnson/markdownlint, MIT © David Anson).
-import { parse, postprocess, preprocess } from 'micromark';
-import { directive } from 'micromark-extension-directive';
-import { frontmatter } from 'micromark-extension-frontmatter';
-import { gfmAutolinkLiteral } from 'micromark-extension-gfm-autolink-literal';
-import { gfmFootnote } from 'micromark-extension-gfm-footnote';
-import { gfmTable } from 'micromark-extension-gfm-table';
-import { math } from 'micromark-extension-math';
-import { markdocSyntax } from './markdoc/syntax.js';
-import { structureMarkdocTags } from './markdoc/structure.js';
-const frontmatterExtension = frontmatter(['yaml']);
-const baseExtensions = [
-    directive(),
-    gfmAutolinkLiteral(),
-    gfmFootnote(),
-    gfmTable(),
-    math(),
-    frontmatterExtension,
-];
-// Forces htmlFlow (block HTML) regions to be reparsed as if they were
-// regular inline content -- disabling the `codeIndented`/`htmlFlow` block
-// constructs makes micromark fall through to paragraph/inline tokenization
-// for the same text, which is exactly what upstream markdownlint's own
-// `micromark-parse.mjs` shim does (it disables the identical pair) to
-// produce real `htmlText` tokens for tags inside HTML blocks. See
-// `reparseHtmlFlow` below.
-const htmlFlowReparseExtension = { disable: { null: ['codeIndented', 'htmlFlow'] } };
-function getEvents(content, extensions) {
-    const parseContext = parse({ extensions });
-    const chunks = preprocess()(content, undefined, true);
-    return postprocess(parseContext.document().write(chunks));
-}
-/**
- * Builds a Token tree from a flat micromark event list. `lineOffset` and
- * `firstLineColumnOffset` translate positions that are relative to
- * `content` (starting at line 1, column 1) into the surrounding
- * document's coordinate space -- used by `reparseHtmlFlow` below to splice
- * a reparsed `htmlFlow` block's tokens back in at their real position.
- * `content` itself must already be the exact document (or sub-region)
- * text so `start.offset`/`end.offset` slicing stays correct.
- */
-function buildTree(events, content, lineOffset = 0, firstLineColumnOffset = 0) {
-    const children = [];
-    const flat = [];
-    const stack = [];
-    const adjustLine = (line) => line + lineOffset;
-    const adjustColumn = (line, column) => line === 1 ? column + firstLineColumnOffset : column;
-    for (const event of events) {
-        const [kind, mmToken] = event;
-        if (kind === 'enter') {
-            const parent = stack[stack.length - 1] ?? null;
-            const token = {
-                type: mmToken.type,
-                startLine: adjustLine(mmToken.start.line),
-                startColumn: adjustColumn(mmToken.start.line, mmToken.start.column),
-                endLine: adjustLine(mmToken.end.line),
-                endColumn: adjustColumn(mmToken.end.line, mmToken.end.column),
-                text: '',
-                children: [],
-                parent,
-            };
-            (parent ? parent.children : children).push(token);
-            flat.push(token);
-            stack.push(token);
-        }
-        else {
-            const token = stack.pop();
-            if (token) {
-                // Slice from the original content via absolute offsets rather than
-                // `context.sliceSerialize`. Nested/subtokenized content (e.g. list
-                // items containing sublists) can leave an exit event's `context`
-                // pointing at a tokenizer buffer that no longer covers this token,
-                // crashing `sliceSerialize`. `start.offset`/`end.offset` are stable
-                // document-absolute positions, so slicing `content` directly avoids
-                // depending on which context object emitted the event, matching
-                // markdownlint's lib/micromark-parse.mjs `getText` helper (MIT).
-                token.text = content.slice(mmToken.start.offset, mmToken.end.offset);
-                token.endLine = adjustLine(mmToken.end.line);
-                token.endColumn = adjustColumn(mmToken.end.line, mmToken.end.column);
-            }
-        }
-    }
-    return { children, flat };
-}
-/**
- * Returns true iff the token is an HTML comment (`<!-- ... -->`) that is
- * valid per the CommonMark spec. Duplicated (narrowly) from
- * rules/token/helpers.ts's `isHtmlFlowComment` rather than imported --
- * that module is rule-layer code that itself depends on parser types, and
- * this parser module must not depend back on the rules layer.
- */
-function isHtmlFlowComment(token) {
-    const { text, type } = token;
-    if (type === 'htmlFlow' && text.startsWith('<!--') && text.endsWith('-->')) {
-        const comment = text.slice(4, -3);
-        return !comment.startsWith('>') && !comment.startsWith('->') && !comment.endsWith('-');
-    }
-    return false;
-}
-/**
- * Re-tokenizes every non-comment `htmlFlow` (block HTML) token's own text
- * as inline content, splicing the result in as that token's children (and
- * into `flat`) so rules that look for `htmlText` tokens (e.g. MD033
- * no-inline-html) see tags inside HTML blocks -- not just genuinely
- * inline HTML -- exactly like upstream markdownlint (see
- * `htmlFlowReparseExtension`'s doc comment). Mutates `tree.flat` in place;
- * `tree.children` already references the same token objects, so no
- * further mutation is needed there.
- *
- * A block like:
- *   <details>
- *   <summary>Text</summary>
- * is ONE `htmlFlow` token whose raw text spans both lines; reparsing it
- * with `codeIndented`/`htmlFlow` disabled naturally produces `htmlText`
- * tokens for `<details>`, `<summary>`, and `</summary>` as descendants,
- * which is what makes the fix work even when multiple tags/lines are
- * inside a single flow block.
- */
-function reparseHtmlFlow(tree) {
-    const htmlFlowTokens = tree.flat.filter((token) => token.type === 'htmlFlow' && !isHtmlFlowComment(token));
-    for (const token of htmlFlowTokens) {
-        const events = getEvents(token.text, [...baseExtensions, htmlFlowReparseExtension]);
-        const reparsed = buildTree(events, token.text, token.startLine - 1, token.startColumn - 1);
-        // Re-parent every reparsed token onto the original htmlFlow token, mark
-        // it `inHtmlFlow` (see Token's doc comment -- lets `filterByTypes`
-        // exclude this synthetic content by default, matching upstream), and
-        // add them all to the shared flat list. The htmlFlow token's OWN
-        // top-level type/text/position are left untouched -- only its
-        // (previously empty-of-inline-tags) children are replaced.
-        for (const descendant of reparsed.flat)
-            descendant.inHtmlFlow = true;
-        for (const child of reparsed.children)
-            child.parent = token;
-        token.children = reparsed.children;
-        // Push one-by-one: spreading an unbounded array as arguments overflows
-        // the call stack on huge HTML blocks (tens of thousands of lines), and
-        // this pass must never throw on a large document.
-        for (const descendant of reparsed.flat)
-            tree.flat.push(descendant);
-    }
-}
-export function parseMarkdown(content, options = {}) {
-    // With the flag off, the extension list and the post-passes are identical to
-    // a parse that knows nothing about Markdoc -- `markdocSyntax()` is never even
-    // instantiated -- so the tree stays byte-identical by construction.
-    const blockExtensions = options.embedded
-        ? baseExtensions.filter((extension) => extension !== frontmatterExtension)
-        : baseExtensions;
-    const extensions = options.markdoc
-        ? [...blockExtensions, markdocSyntax(content)]
-        : blockExtensions;
-    const events = getEvents(content, extensions);
-    const tree = buildTree(events, content);
-    reparseHtmlFlow(tree);
-    if (options.markdoc)
-        structureMarkdocTags(tree);
-    return tree;
-}
-/**
- * Filters the tree's flat token list by type. By default, tokens produced
- * by reparsing an `htmlFlow` block (see `reparseHtmlFlow` above) are
- * EXCLUDED -- matching upstream markdownlint's own `filterByTypes(tokens,
- * types, htmlFlow)` helper, whose `htmlFlow` parameter defaults to falsy.
- * Pass `includeHtmlFlow: true` for rules that explicitly want to see
- * inside HTML blocks too (upstream's MD033/no-inline-html and
- * MD045/no-alt-text opt in this way; see their recheck ports for the same
- * opt-in).
- */
-export function filterByTypes(tree, types, includeHtmlFlow = false) {
-    return tree.flat.filter((token) => types.includes(token.type) && (includeHtmlFlow || !token.inHtmlFlow));
-}
-//# sourceMappingURL=index.js.map

package/dist/parser/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,iFAAiF;AACjF,mEAAmE;AACnE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAIhD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAI9D,MAAM,oBAAoB,GAAG,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,MAAM,cAAc,GAAG;IACrB,SAAS,EAAE;IACX,kBAAkB,EAAE;IACpB,WAAW,EAAE;IACb,QAAQ,EAAE;IACV,IAAI,EAAE;IACN,oBAAoB;CACrB,CAAC;AAEF,sEAAsE;AACtE,0EAA0E;AAC1E,2EAA2E;AAC3E,uEAAuE;AACvE,sEAAsE;AACtE,kEAAkE;AAClE,2BAA2B;AAC3B,MAAM,wBAAwB,GAAc,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,cAAc,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC;AAEhG,SAAS,SAAS,CAAC,OAAe,EAAE,UAAuB;IACzD,MAAM,YAAY,GAAG,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,UAAU,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;IACtD,OAAO,WAAW,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAChB,MAAe,EACf,OAAe,EACf,UAAU,GAAG,CAAC,EACd,qBAAqB,GAAG,CAAC;IAEzB,MAAM,QAAQ,GAAY,EAAE,CAAC;IAC7B,MAAM,IAAI,GAAY,EAAE,CAAC;IACzB,MAAM,KAAK,GAAY,EAAE,CAAC;IAC1B,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,GAAG,UAAU,CAAC;IACvD,MAAM,YAAY,GAAG,CAAC,IAAY,EAAE,MAAc,EAAE,EAAE,CACpD,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAAC;IACvD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,KAAK,CAAC;QAC9B,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;YACrB,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC;YAC/C,MAAM,KAAK,GAAU;gBACnB,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,SAAS,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;gBACzC,WAAW,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC;gBACnE,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;gBACrC,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;gBAC7D,IAAI,EAAE,EAAE;gBACR,QAAQ,EAAE,EAAE;gBACZ,MAAM;aACP,CAAC;YACF,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAClD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;YAC1B,IAAI,KAAK,EAAE,CAAC;gBACV,mEAAmE;gBACnE,mEAAmE;gBACnE,iEAAiE;gBACjE,mEAAmE;gBACnE,oEAAoE;gBACpE,oEAAoE;gBACpE,gEAAgE;gBAChE,iEAAiE;gBACjE,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACrE,KAAK,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAC7C,KAAK,CAAC,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,KAAY;IACrC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC;IAC7B,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3E,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAClC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACzF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAS,eAAe,CAAC,IAAe;IACtC,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CACrC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAClE,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,cAAc,EAAE,wBAAwB,CAAC,CAAC,CAAC;QACpF,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC,EAAE,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;QAC3F,wEAAwE;QACxE,mEAAmE;QACnE,qEAAqE;QACrE,iEAAiE;QACjE,8DAA8D;QAC9D,2DAA2D;QAC3D,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,IAAI;YAAE,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC;QACrE,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,QAAQ;YAAE,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC;QAC5D,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;QACnC,uEAAuE;QACvE,uEAAuE;QACvE,kDAAkD;QAClD,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AAYD,MAAM,UAAU,aAAa,CAAC,OAAe,EAAE,OAAO,GAAiB,EAAE;IACvE,6EAA6E;IAC7E,8EAA8E;IAC9E,oEAAoE;IACpE,MAAM,eAAe,GAAG,OAAO,CAAC,QAAQ;QACtC,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,oBAAoB,CAAC;QAC1E,CAAC,CAAC,cAAc,CAAC;IACnB,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO;QAChC,CAAC,CAAC,CAAC,GAAG,eAAe,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;QAC9C,CAAC,CAAC,eAAe,CAAC;IACpB,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAC9C,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,eAAe,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,OAAO,CAAC,OAAO;QAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAe,EACf,KAAwB,EACxB,eAAe,GAAG,KAAK;IAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CACrB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAChF,CAAC;AACJ,CAAC"}

package/dist/parser/markdoc/extract-statics.d.ts

@@ -1,45 +0,0 @@
-import type { MarkdocAttributeSchema, MarkdocSchema } from './schema.js';
-/** Enough of a real Markdoc `Config['tags'][name]['attributes'][name]` entry to extract statics from. */
-export interface RawMarkdocAttribute {
-    type?: unknown;
-    required?: boolean;
-    default?: unknown;
-    matches?: unknown;
-}
-/** Enough of a real Markdoc `Config['tags'][name]` entry to extract statics from. */
-export interface RawMarkdocTag {
-    selfClosing?: boolean;
-    attributes?: Record<string, RawMarkdocAttribute>;
-    validate?: unknown;
-}
-export type RawMarkdocTagMap = Record<string, RawMarkdocTag>;
-/**
- * Converts one raw Markdoc attribute definition into recheck's
- * `MarkdocAttributeSchema`.
- *
- * `tagHasValidate` forces `dynamic: true` regardless of this attribute's own
- * type. A tag-level `validate()` -- for example `img`'s src/srcSet/images
- * mutual-exclusivity check, `code-snippet`'s from/after and to/before checks,
- * or `diagram`'s type/align re-checks -- can read and reject any of the tag's
- * attributes for reasons this generator can't discover from the schema object
- * alone, since that would mean analyzing an arbitrary JS function body. So
- * every attribute of a `validate()`-carrying tag is conservatively marked
- * dynamic, even one with a plain `String`/`Number`/`Boolean` type and a
- * `matches` array (`img.align`, `diagram.type`).
- *
- * Recorded facets (`required`, `default`, `enum`) are kept even when dynamic:
- * `dynamic` only tells a value-checking rule to skip them, it doesn't make the
- * facet itself unknown.
- */
-export declare function extractAttribute(rawAttribute: RawMarkdocAttribute, tagHasValidate: boolean): MarkdocAttributeSchema;
-/**
- * Composes three raw Markdoc tag maps in caller-chosen precedence order
- * (later arguments win a name collision) and converts every tag to recheck's
- * statics-only `MarkdocSchema`. Both callers share this precedence-then-convert
- * shape: the built-in generator composes markdoc + portal + theme in Realm's
- * own override order; the `recheck --generate-markdoc-schema` action extracts one
- * project module's tags at a time and passes empty maps for the other two, so
- * the composition is a no-op and only that module's tags come out.
- */
-export declare function extractStatics(themeTagMap: RawMarkdocTagMap, markdocBuiltinTags: RawMarkdocTagMap, portalBuiltInTagMap: RawMarkdocTagMap): MarkdocSchema;
-//# sourceMappingURL=extract-statics.d.ts.map

package/dist/parser/markdoc/extract-statics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-statics.d.ts","sourceRoot":"","sources":["../../../src/parser/markdoc/extract-statics.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,sBAAsB,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAC;AAE3F,yGAAyG;AACzG,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qFAAqF;AACrF,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACjD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAe7D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,mBAAmB,EACjC,cAAc,EAAE,OAAO,GACtB,sBAAsB,CAoDxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,gBAAgB,EAC7B,kBAAkB,EAAE,gBAAgB,EACpC,mBAAmB,EAAE,gBAAgB,GACpC,aAAa,CA+Bf"}

package/dist/parser/markdoc/extract-statics.js

@@ -1,139 +0,0 @@
-// The single implementation of "a real Markdoc tag map -> recheck's
-// statics-only MarkdocSchema". Two callers share it and must never define
-// "what counts as a static facet" two different ways:
-//   - `scripts/generate-markdoc-schema.mjs`, which resolves Realm's composed
-//     built-in schema (markdoc + portal + theme) for the committed
-//     `src/data/markdoc-realm-schema.ts`, and re-exports these functions
-//     unchanged so its own drift test keeps working.
-//   - `src/commands/markdoc-schema.ts`, the `recheck --generate-markdoc-schema` CLI
-//     command, which extracts statics from a project's own schema module(s).
-//
-// Lives under `src/` (not `scripts/`) so the built CLI can import it at
-// runtime: `scripts/`'s own generator imports `@redocly/theme` and
-// `@redocly/portal`, both devDependencies-only, and this module must stay
-// free of any such import so requiring it from a published package never
-// drags those in.
-//
-// Raw tag/attribute shapes are typed loosely here rather than imported from
-// `@markdoc/markdoc` (also a devDependency-only): this module's declaration
-// file ships with the published package, and a type-only import still leaves
-// a reference downstream consumers' own type-checking would need
-// `@markdoc/markdoc` installed to resolve.
-// The three attribute-type constructors recheck's own format can represent
-// (see MarkdocAttributeSchema's doc comment in ./schema.ts). Every other
-// upstream type -- `Object`, `Array`, a union like `[String, Number]`, a
-// custom class implementing `CustomAttributeTypeInterface` (`RelativePath`,
-// `PartialFile`, ...), or no `type` at all (`debug`'s bare `{ value: {} }`) --
-// has no faithful single-primitive representative, so it's recorded
-// `dynamic: true` instead of guessing.
-const PRIMITIVE_TYPE_NAMES = new Map([
-    [String, 'string'],
-    [Number, 'number'],
-    [Boolean, 'boolean'],
-]);
-/**
- * Converts one raw Markdoc attribute definition into recheck's
- * `MarkdocAttributeSchema`.
- *
- * `tagHasValidate` forces `dynamic: true` regardless of this attribute's own
- * type. A tag-level `validate()` -- for example `img`'s src/srcSet/images
- * mutual-exclusivity check, `code-snippet`'s from/after and to/before checks,
- * or `diagram`'s type/align re-checks -- can read and reject any of the tag's
- * attributes for reasons this generator can't discover from the schema object
- * alone, since that would mean analyzing an arbitrary JS function body. So
- * every attribute of a `validate()`-carrying tag is conservatively marked
- * dynamic, even one with a plain `String`/`Number`/`Boolean` type and a
- * `matches` array (`img.align`, `diagram.type`).
- *
- * Recorded facets (`required`, `default`, `enum`) are kept even when dynamic:
- * `dynamic` only tells a value-checking rule to skip them, it doesn't make the
- * facet itself unknown.
- */
-export function extractAttribute(rawAttribute, tagHasValidate) {
-    const rawType = rawAttribute.type;
-    const primitiveName = typeof rawType === 'function' ? PRIMITIVE_TYPE_NAMES.get(rawType) : undefined;
-    // `type` is non-optional in MarkdocAttributeSchema, and 'string' is the
-    // placeholder for anything non-primitive. It's a faithful placeholder
-    // rather than an arbitrary one: every custom attribute type in
-    // packages/theme (RelativePath, PartialFile, CodeSnippetFile, ...)
-    // implements `validate(value: string)`, so the wire value is always a
-    // string even when the class does extra work with it. A dynamic attribute
-    // is never value-checked anyway -- only the presence of `type` satisfies
-    // the interface.
-    const out = { type: primitiveName ?? 'string' };
-    if (rawAttribute.required === true)
-        out.required = true;
-    // `MarkdocAttributeSchema.default` can only hold a JSON primitive, and some
-    // defaults aren't one: `connect-mcp`'s `options` attribute defaults to an
-    // array (`['cursor', 'vscode', 'copy']`), which the interface has no slot
-    // for. Recording it would produce a schema that doesn't type-check against
-    // its own interface, so drop it rather than guess a representation.
-    // Nothing is lost: a non-primitive default always pairs with a
-    // non-primitive `type`, so the attribute is already `dynamic: true` and no
-    // value check reads its default.
-    const defaultType = typeof rawAttribute.default;
-    if (defaultType === 'string' || defaultType === 'number' || defaultType === 'boolean') {
-        out.default = rawAttribute.default;
-    }
-    // Markdoc's `matches` isn't always an array -- it can also be a RegExp or a
-    // predicate function -- and even when it is an array, its entries aren't
-    // guaranteed to be strings. `MarkdocAttributeSchema.enum` is
-    // `readonly string[]`, so:
-    //   - A non-array `matches` can't be represented as an enum at all, so it
-    //     falls back to `dynamic: true` like a class-typed attribute or a
-    //     `validate()`-carrying tag. Don't guess at a constraint this can't
-    //     statically resolve.
-    //   - An array `matches` with non-string entries is representable, just not
-    //     verbatim, so coerce it with `String(...)` rather than marking it
-    //     dynamic. The enum value check compares a parsed attribute literal's
-    //     source text against the declared enum -- a string comparison either
-    //     way -- so a coerced `'1'`/`'true'` is exactly what it needs.
-    if (rawAttribute.matches !== undefined) {
-        if (Array.isArray(rawAttribute.matches)) {
-            if (rawAttribute.matches.length > 0) {
-                out.enum = rawAttribute.matches.map((value) => String(value));
-            }
-        }
-        else {
-            out.dynamic = true;
-        }
-    }
-    if (primitiveName === undefined || tagHasValidate)
-        out.dynamic = true;
-    return out;
-}
-/**
- * Composes three raw Markdoc tag maps in caller-chosen precedence order
- * (later arguments win a name collision) and converts every tag to recheck's
- * statics-only `MarkdocSchema`. Both callers share this precedence-then-convert
- * shape: the built-in generator composes markdoc + portal + theme in Realm's
- * own override order; the `recheck --generate-markdoc-schema` action extracts one
- * project module's tags at a time and passes empty maps for the other two, so
- * the composition is a no-op and only that module's tags come out.
- */
-export function extractStatics(themeTagMap, markdocBuiltinTags, portalBuiltInTagMap) {
-    const composed = { ...markdocBuiltinTags, ...portalBuiltInTagMap, ...themeTagMap };
-    const tagNames = Object.keys(composed).sort();
-    const tags = {};
-    for (const tagName of tagNames) {
-        const rawSchema = composed[tagName];
-        const tagHasValidate = typeof rawSchema.validate === 'function';
-        const tagOut = {};
-        if (rawSchema.selfClosing === true)
-            tagOut.selfClosing = true;
-        const rawAttributes = rawSchema.attributes;
-        if (rawAttributes) {
-            const attributeNames = Object.keys(rawAttributes).sort();
-            if (attributeNames.length > 0) {
-                const attributesOut = {};
-                for (const attributeName of attributeNames) {
-                    attributesOut[attributeName] = extractAttribute(rawAttributes[attributeName], tagHasValidate);
-                }
-                tagOut.attributes = attributesOut;
-            }
-        }
-        tags[tagName] = tagOut;
-    }
-    return { tags };
-}
-//# sourceMappingURL=extract-statics.js.map

package/dist/parser/markdoc/extract-statics.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-statics.js","sourceRoot":"","sources":["../../../src/parser/markdoc/extract-statics.ts"],"names":[],"mappings":"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"}

package/dist/parser/markdoc/pairing.d.ts

@@ -1,63 +0,0 @@
-import type { Token, TokenTree } from '../types.js';
-export interface MarkdocPair {
-    open: Token;
-    close: Token;
-    /**
-     * Nesting depth of `open` at the moment it was pushed: 0 for a top-level tag,
-     * 1 for a tag opened inside exactly one other, and so on. It stays fixed even
-     * when `close` jumps over an intervening unmatched open (see `crossed`), since
-     * it describes where `open` appeared, not where its match landed.
-     */
-    depth: number;
-}
-/**
- * The five buckets are disjoint: a pair lands in `pairs` or `crossed` but never
- * both, and a token appears in at most one bucket.
- */
-export interface MarkdocPairing {
-    /** Cleanly matched open/close pairs (no crossing involved on either side). */
-    pairs: MarkdocPair[];
-    /** Opens with no close by EOF (excluding schema-known void tags, below). */
-    unclosed: Token[];
-    /** Closes that match no open anywhere on the stack. */
-    orphaned: Token[];
-    /** Matched pairs whose open or close jumped, or was jumped by, another pair. */
-    crossed: MarkdocPair[];
-    /** Opens whose name is schema-declared self-closing, written without `/%}`. */
-    voidMissingSlash: Token[];
-}
-/**
- * A "nothing was paired" result for callers that must still supply a
- * `MarkdocPairing` but have no reason to run the pass -- the runner uses it when
- * the Markdoc flag is on but no active rule can read the buckets anyway. A
- * factory rather than a shared constant, because the buckets are mutable arrays
- * and one shared instance would let an accidental push leak across files.
- */
-export declare function emptyMarkdocPairing(): MarkdocPairing;
-export interface PairingOptions {
-    /**
-     * Tag names a schema declares self-closing. A plain `Set<string>` rather than
-     * a dependency on the schema module, so the schema's shape can change without
-     * this pass knowing anything beyond which names never take a close tag.
-     */
-    selfClosingTags?: ReadonlySet<string>;
-}
-/**
- * Computes open/close pairing for a document's `markdocTag` tokens with a single
- * stack walk in document order. The filtered list is sorted by position rather
- * than trusting whatever order `tree.flat` happens to be in, since
- * `structureMarkdocTags` (structure.ts) appends its own synthesized children to
- * the end of that same array.
- *
- * Deliberate divergence from upstream Markdoc, which tests a close only against
- * the immediate top of its stack and never searches deeper: for
- * `{% a %}{% b %}{% /a %}{% /b %}` upstream reports a missing-closing plus a
- * missing-opening and lets `a`'s node swallow everything to EOF, while this pass
- * searches the whole stack innermost-first and reports both pairs as `crossed`.
- * "These two pairs are interleaved" is the more actionable diagnostic, and a
- * crossing can never silently land in `pairs`, so no error upstream reports is
- * lost. The cost is that consumers relying on pair ranges see a narrower range
- * for a crossed `open` than upstream's AST would give.
- */
-export declare function computeMarkdocPairing(tree: TokenTree, options?: PairingOptions): MarkdocPairing;
-//# sourceMappingURL=pairing.d.ts.map

package/dist/parser/markdoc/pairing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pairing.d.ts","sourceRoot":"","sources":["../../../src/parser/markdoc/pairing.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGpD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,4EAA4E;IAC5E,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,uDAAuD;IACvD,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,gFAAgF;IAChF,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,+EAA+E;IAC/E,gBAAgB,EAAE,KAAK,EAAE,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,CAEpD;AAED,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACvC;AAmCD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,cAAmB,GAC3B,cAAc,CAsDhB"}

package/dist/parser/markdoc/pairing.js

@@ -1,94 +0,0 @@
-/**
- * A "nothing was paired" result for callers that must still supply a
- * `MarkdocPairing` but have no reason to run the pass -- the runner uses it when
- * the Markdoc flag is on but no active rule can read the buckets anyway. A
- * factory rather than a shared constant, because the buckets are mutable arrays
- * and one shared instance would let an accidental push leak across files.
- */
-export function emptyMarkdocPairing() {
-    return { pairs: [], unclosed: [], orphaned: [], crossed: [], voidMissingSlash: [] };
-}
-// Kinds that never enter the pairing stack: annotation, variable, and function
-// spans carry no tag name at all, a self-closing tag (`{% x /%}`) is already
-// complete on its own, and a malformed span is left inert so it cannot disturb
-// the pairing of the well-formed tags around it (the syntax-level rule owns
-// reporting it).
-const NEVER_PAIRED_KINDS = new Set([
-    'annotation',
-    'variable',
-    'function',
-    'tag-self-closing',
-    'malformed',
-]);
-/** The tag's own name, from its synthesized `markdocTagName` child (absent
- * only for the kinds already filtered out above, where it's `null`). */
-function tagName(token) {
-    const nameChild = token.children.find((child) => child.type === 'markdocTagName');
-    return nameChild ? nameChild.text : null;
-}
-/**
- * Computes open/close pairing for a document's `markdocTag` tokens with a single
- * stack walk in document order. The filtered list is sorted by position rather
- * than trusting whatever order `tree.flat` happens to be in, since
- * `structureMarkdocTags` (structure.ts) appends its own synthesized children to
- * the end of that same array.
- *
- * Deliberate divergence from upstream Markdoc, which tests a close only against
- * the immediate top of its stack and never searches deeper: for
- * `{% a %}{% b %}{% /a %}{% /b %}` upstream reports a missing-closing plus a
- * missing-opening and lets `a`'s node swallow everything to EOF, while this pass
- * searches the whole stack innermost-first and reports both pairs as `crossed`.
- * "These two pairs are interleaved" is the more actionable diagnostic, and a
- * crossing can never silently land in `pairs`, so no error upstream reports is
- * lost. The cost is that consumers relying on pair ranges see a narrower range
- * for a crossed `open` than upstream's AST would give.
- */
-export function computeMarkdocPairing(tree, options = {}) {
-    const selfClosingTags = options.selfClosingTags ?? new Set();
-    const tags = tree.flat
-        .filter((token) => token.type === 'markdocTag')
-        .sort((a, b) => a.startLine - b.startLine || a.startColumn - b.startColumn);
-    const stack = [];
-    const pairs = [];
-    const crossed = [];
-    const orphaned = [];
-    for (const token of tags) {
-        const kind = token.markdocKind;
-        if (kind === undefined || NEVER_PAIRED_KINDS.has(kind))
-            continue;
-        const name = tagName(token);
-        if (name === null)
-            continue; // defensive only: every tag-open/tag-close carries a name
-        if (kind === 'tag-open') {
-            stack.push({ token, name, depth: stack.length, crossed: false });
-            continue;
-        }
-        // kind === 'tag-close': innermost-first search for the nearest same-name open.
-        let matchIndex = -1;
-        for (let i = stack.length - 1; i >= 0; i--) {
-            if (stack[i].name === name) {
-                matchIndex = i;
-                break;
-            }
-        }
-        if (matchIndex === -1) {
-            orphaned.push(token);
-            continue;
-        }
-        const jumpedOver = matchIndex !== stack.length - 1;
-        if (jumpedOver) {
-            for (let i = matchIndex + 1; i < stack.length; i++)
-                stack[i].crossed = true;
-        }
-        const [matched] = stack.splice(matchIndex, 1);
-        const pair = { open: matched.token, close: token, depth: matched.depth };
-        (jumpedOver || matched.crossed ? crossed : pairs).push(pair);
-    }
-    const unclosed = [];
-    const voidMissingSlash = [];
-    for (const entry of stack) {
-        (selfClosingTags.has(entry.name) ? voidMissingSlash : unclosed).push(entry.token);
-    }
-    return { pairs, unclosed, orphaned, crossed, voidMissingSlash };
-}
-//# sourceMappingURL=pairing.js.map

package/dist/parser/markdoc/pairing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pairing.js","sourceRoot":"","sources":["../../../src/parser/markdoc/pairing.ts"],"names":[],"mappings":"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"}