diff --git a/src/gen-tm.ts b/src/gen-tm.ts
index 3dad3e5..8d5d580 100644
--- a/src/gen-tm.ts
+++ b/src/gen-tm.ts
@@ -69,11 +69,16 @@ function escapeForCharClass(s: string): string {
return s.replace(/[\[\]\\^-]/g, '\\$&');
}
-/** A CASE-INSENSITIVE, Onigmo-PORTABLE pattern matching `s` regardless of letter case.
- * Each cased letter becomes a two-char class (`s` → `[Ss]`); other chars are escaped as
- * usual. We do NOT use an inline `(?i)` flag — vscode-textmate/Onigmo does not honor inline
- * case flags reliably (the tm-diagnostics gate rejects them). Used by the markup emitter so a
- * raw-text element (`` after a JS `//` comment (tmbundle#85) — or inside a JS string —
- // still closes the element, matching parse5 / the HTML tokenizer, which close at the FIRST
- // `` regardless of embedded-language context. The embed stays ONE continuous
- // region across lines (the `while` only TESTS, never re-anchors), so a multi-line template
- // literal / block comment in the body is unbroken; only a line that actually contains the
- // close tag drops. The close-tag test is `` / END-OF-LINE (`$`): the EOL
- // alternative drops a line whose `` DEFERRED to a later line (tmbundle#97),
- // so that line leaves the embed and the sibling `#-close-ml` re-embeds its pre-close
- // content. CRUCIALLY the line-start drop FORCE-UNWINDS a still-open embedded region
- // (e.g. a trailing unterminated `type T =` whose body would otherwise read `` as
- // `< script >` type-args) — an `end:(?=-close` rule below. The close tag is matched by host #tag.
- repository[key] = {
- name: `meta.${tag}.${L}`,
- begin: `(${o})(${tagRe})\\b${attrs}(${c})`,
- beginCaptures: { '1': { name: sOpen }, '2': { name: sName }, '3': attrCap, '4': { name: sClose } },
- while: `^(?!.*${o}${slash}${tagRe}(?:[\\s${ccClose}]|$))`,
- contentName: embed,
- patterns: [{ include: embed }],
- };
- // (3) CLOSE LINE with leading content — `BODY` where BODY shares the close's line (the
- // open tag was on an earlier line, so this is NOT the `-inline` single-line shape; and the
- // `begin/while` above DROPS this line because it contains the close). Without this, that
- // pre-close BODY falls to plain host text (the #2060 / #5538 same-line-close gap). Here it is
- // re-tokenized as a BOUNDED capture-embed: BODY is captured up to the close and run through
- // the embed in ISOLATION, so the embed's own greedy line-comment / regex / unterminated
- // construct physically cannot reach across the close — the close stays clean tag punctuation
- // AND its preceding code is highlighted. The BODY needs ≥1 char before the close, so a BARE
- // close line (just ``) does NOT match here — it stays on the `begin/while` force-unwind
- // path (preserving #5538's open-type unwind). The BODY is a tempered-greedy run
- // `(?:(?!…` (that whole line is the `-inline` shape, claimed earlier) nor
- // swallow a following block's open tag, yet a bare `<` in the body (`a < b`) is fine. Agnostic:
- // keys only on the tag + `<`/`/`/`>` delimiters (DATA), never on the embed's syntax.
- repository[`${key}-close`] = {
- name: `meta.${tag}.${L}`,
- match: `^(\\s*)((?:(?!${o}${tagRe}\\b).)+?)(${o}${slash})(${tagRe})\\s*(${c})`,
- captures: { '2': bodyCap, '3': { name: sOpen }, '4': { name: sName }, '5': { name: sClose } },
- };
- // (3b) ORPHAN CLOSE LINE whose `>` is DEFERRED — `BODY` on a later
- // one (the case-(3) sibling but with the close `>` split off, the tmbundle#97 deferred-`>`
- // shape after the body sits on its own line). The widened `begin/while` (2) drops this line
- // (its `` is deferred), and `end`s at the deferred `>`. Same tempered-greedy
- // BODY run as (3) so it can't swallow a following block's `` (#97)
- top.push({ include: `#${key}` });
- top.push({ include: `#${key}-close` }); // orphan close line (BODY) — after the open-tag rules
- top.push({ include: `#${key}-close-ml` }); // orphan close line with a DEFERRED `>` (#97)
+ const closeAhead = `${o}${slash}${tagRe}(?:[\\s${ccClose}]|$)`; // `` / EOL (a DEFERRED `>` on a later line, tmbundle#97)
+ if (forceClose) {
+ // (2) multi-line `begin/while` — the `while` re-checks each line and DROPS the region
+ // (popping any open embedded region) at the first line CONTAINING `` (the `.*`
+ // reaches it anywhere on the line, not just `^\s*` at the start). So the close wins even
+ // MID-LINE: a `` after a JS `//` comment (tmbundle#85) — or inside a JS string —
+ // still closes the element, matching parse5 / the HTML tokenizer, which close at the FIRST
+ // `` regardless of embedded-language context. The embed stays ONE continuous
+ // region across lines (the `while` only TESTS, never re-anchors), so a multi-line template
+ // literal / block comment in the body is unbroken; only a line that actually contains the
+ // close tag drops. The close-tag test is `` / END-OF-LINE (`$`): the EOL
+ // alternative drops a line whose `` DEFERRED to a later line (tmbundle#97),
+ // so that line leaves the embed and the sibling `#-close-ml` re-embeds its pre-close
+ // content. CRUCIALLY the line-start drop FORCE-UNWINDS a still-open embedded region
+ // (e.g. a trailing unterminated `type T =` whose body would otherwise read `` as
+ // `< script >` type-args) — an `end:(?=-close` rule below. The close tag is matched by host #tag.
+ // This is the `forceClose` shape — for a body that can swallow the close mid-line (JS): it
+ // CANNOT keep a non-first DIALECT's close-line content in its own dialect (the dropped line
+ // leaves the region and lands on a lang-INDEPENDENT close rule — only the first fires). That
+ // is the dual of #85: mid-line force-close OR dialect-correct close lines, not both. Script
+ // takes force-close; a well-behaved embed (CSS) takes the `else` branch (dialect-correct).
+ repository[key] = {
+ name: `meta.${tag}.${L}`,
+ begin: `(${o})(${tagRe})\\b${attrs}(${c})`,
+ beginCaptures: { '1': { name: sOpen }, '2': { name: sName }, '3': attrCap, [g(4)]: { name: sClose } },
+ while: `^(?!.*${closeAhead})`,
+ contentName: embed,
+ patterns: [{ include: embed }],
+ };
+ // (3) CLOSE LINE with leading content — `BODY` where BODY shares the close's line (the
+ // open tag was on an earlier line, so this is NOT the `-inline` single-line shape; and the
+ // `begin/while` above DROPS this line because it contains the close). Without this, that
+ // pre-close BODY falls to plain host text (the #2060 / #5538 same-line-close gap). Here it is
+ // re-tokenized as a BOUNDED capture-embed: BODY is captured up to the close and run through
+ // the embed in ISOLATION, so the embed's own greedy line-comment / regex / unterminated
+ // construct physically cannot reach across the close — the close stays clean tag punctuation
+ // AND its preceding code is highlighted. The BODY needs ≥1 char before the close, so a BARE
+ // close line (just ``) does NOT match here — it stays on the `begin/while` force-unwind
+ // path (preserving #5538's open-type unwind). The BODY is a tempered-greedy run
+ // `(?:(?!…` (that whole line is the `-inline` shape, claimed earlier) nor
+ // swallow a following block's open tag, yet a bare `<` in the body (`a < b`) is fine. Agnostic:
+ // keys only on the tag + `<`/`/`/`>` delimiters (DATA), never on the embed's syntax.
+ top.push({ include: `#${key}` });
+ // The close-line rules (3)/(3b) key on the TAG ONLY (a close line carries no `lang=`), so emitting
+ // them per dialect yields byte-identical regex where only the first-included fires and the rest are
+ // dead (monogram#43 "will never match" / "all raw embedded languages"). Emit them ONCE — on the
+ // lang-less call (`langVal === undefined`), with the default embed — and skip them for every dialect.
+ if (langVal === undefined) {
+ repository[`${key}-close`] = {
+ name: `meta.${tag}.${L}`,
+ match: `^(\\s*)((?:(?!${o}${tagRe}\\b).)+?)(${o}${slash})(${tagRe})\\s*(${c})`,
+ captures: { '2': bodyCap, '3': { name: sOpen }, '4': { name: sName }, '5': { name: sClose } },
+ };
+ // (3b) ORPHAN CLOSE LINE whose `>` is DEFERRED — `BODY` on a later
+ // one (the case-(3) sibling but with the close `>` split off, the tmbundle#97 deferred-`>`
+ // shape after the body sits on its own line). The widened `begin/while` (2) drops this line
+ // (its `` is deferred), and `end`s at the deferred `>`. Same tempered-greedy
+ // BODY run as (3) so it can't swallow a following block's `) — once per tag, lang-independent
+ top.push({ include: `#${key}-close-ml` }); // orphan close line with a DEFERRED `>` (#97)
+ }
+ } else {
+ // (2′) WELL-BEHAVED embed (no greedy construct can swallow the close, e.g. CSS) — a single
+ // `begin/end` region with a LOOKAHEAD `end` that never CONSUMES the close tag. Because the
+ // embed (`contentName`/`patterns`) stays active right up to ``, the open tag on an earlier line) is tokenised by THIS region's embed —
+ // so it keeps its own DIALECT (issue #43); the lang-independent top-level close rules of the
+ // `forceClose` path (which only the first-listed dialect could win) are GONE. The `]|$)` after `` (#97) shape (the `$`/ws alternatives), so no separate close-ml
+ // rule is needed. This is the official Vue grammar's `multi-line-style-tag-stuff` body shape,
+ // generalised to the config delimiters. Safe ONLY for embeds that cannot force-close mid-line
+ // (see `forceClose` doc on RawEmbed) — script keeps the `if` branch.
+ repository[key] = {
+ name: `meta.${tag}.${L}`,
+ begin: `(${o})(${tagRe})\\b${attrs}(${c})`,
+ beginCaptures: { '1': { name: sOpen }, '2': { name: sName }, '3': attrCap, [g(4)]: { name: sClose } },
+ end: `(?=${closeAhead})`,
+ contentName: embed,
+ patterns: [{ include: embed }],
+ };
+ top.push({ include: `#${key}` });
+ }
};
// Multi-line START TAG variant — `` (force-expand-multiline
// formatting; vuejs/language-tools#3999). A TextMate `begin` is single-line, so the entries
@@ -4057,11 +4117,18 @@ function generateMarkupTm(grammar: CstGrammar, grammarName: string, scopeName: s
for (const tag of m.rawText?.tags ?? []) {
const spec = m.rawText!.embed?.[tag] ?? (tokScope(m.rawText!.token) ?? `source.${L}`);
if (typeof spec === 'string') {
+ // A bare-string embed has no dialects (no per-dialect close collision) — keep the `begin/while`
+ // force-close shape (a single-blob `source.js`/`source.css` body still needs #85/#5538 fidelity).
emitRaw(`raw-${tag}`, tag, spec);
} else {
+ // Whether the embed can swallow the close mid-line (script) or is well-behaved (style). All of
+ // a tag's dialects share one verdict (the lang on the open tag selects scope, not close shape),
+ // so derive `forceClose` ONCE and pass it to every dialect's emit. Default false = dialect-correct
+ // close lines via lookahead-`end` (issue #43); script opts in to the `while` (RawEmbed.forceClose).
+ const forceClose = spec.forceClose ?? false;
// lang-specific regions FIRST (they require the matching lang= attr), default LAST.
- for (const [langVal, langEmbed] of Object.entries(spec.lang ?? {})) emitRaw(`raw-${tag}-${langVal}`, tag, langEmbed, langVal);
- emitRaw(`raw-${tag}`, tag, spec.default);
+ for (const [langVal, langEmbed] of Object.entries(spec.lang ?? {})) emitRaw(`raw-${tag}-${langVal}`, tag, langEmbed, langVal, forceClose);
+ emitRaw(`raw-${tag}`, tag, spec.default, undefined, forceClose);
}
emitRawMultiline(tag, spec); // multi-line start-tag variant (one per tag, all langs inside)
}
@@ -4589,14 +4656,19 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// ── 1. Detect angle bracket ambiguity ──
const angleBracket = detectAngleBracketAmbiguity(grammar);
const angleBracketExclude = new Set(angleBracket ? ['<', '>'] : []);
+ // JSX/TSX dialect — detected here (ahead of its own section below) so its derived
+ // close-tag token (``, the `sep` `,`, the `string`
- // quotes) and SHARED by both sides so they can't drift: #arrow-type-parameters'
- // positive begin guard (below) and its inverse — the carve-out appended to the JSX
- // expression-start trigger in generateJsxPatterns. Built only when `<…>` is a
- // generic delimiter; null for a plain JS `.jsx` grammar (no generics).
+ // quotes, the JSX close-tag) and SHARED by both sides so they can't drift:
+ // #arrow-type-parameters' positive begin guard (below) and its inverse — the
+ // carve-out appended to the JSX expression-start trigger in generateJsxPatterns.
+ // Built only when `<…>` is a generic delimiter; null for a plain JS `.jsx` grammar
+ // (no generics).
const angleDisambig = angleBracket
- ? jsxDisambigDelims(grammar, identPattern, angleBracket.separator, detectArrowParamDelims(grammar), angleBracket.innerRuleName)
+ ? jsxDisambigDelims(grammar, identPattern, angleBracket.separator, detectArrowParamDelims(grammar), angleBracket.innerRuleName, jsx?.closeTok ?? null)
: null;
if (angleBracket) {
@@ -4621,11 +4693,10 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// comparison is added later in the ordering pass
}
- // ── 1a. Detect JSX/TSX dialect ──
+ // ── 1a. Emit JSX/TSX dialect patterns ──
// Purely additive: emitted only when the grammar declares the JSX delimiter
- // tokens (`/>` and `` and `` and `N` (or auto-detect `|`) block scalar whose mapping sits inside a COMPACT block sequence
+ // (`- - abc: |2`) has a content floor of `dashPrefixWidth + N`, where `dashPrefixWidth` is the full
+ // width of the `(- )+` prefix. That width grows ONE column-group per dash, so a FLAT per-line floor
+ // (`\1[ \t]\3 {N}`, which captures only the FIRST dash's column) is correct only at depth 1 and
+ // over-paints every deeper comment/dedent line at depth ≥ 2 — the bug a single backref pair cannot
+ // express for arbitrary depth (a bounded d=2,3 just moves the wall to d=4).
+ //
+ // The fix is the maintained RedCMD YAML grammar's shape: each `- ` opens its OWN `\G`-anchored child
+ // region that re-asserts (and CONSUMES) its level's indentation each line, so the rule stack carries
+ // the column down through arbitrary nesting and the block scalar's floor is expressed RELATIVE to the
+ // innermost level's advanced `\G` (additive over the enclosing columns) rather than an absolute
+ // per-line formula. Unlike the §2c #block-sequence (which stays zero-width on continuation lines so a
+ // nested level can reclaim its own sibling), THIS region's value is a single block scalar — there are
+ // no per-level siblings to reclaim — so its `while` CONSUMES `\1[ \t]\3` (this level's indent + the
+ // dash's own column + the run after the dash) each line, advancing `\G` to exactly `dashPrefixWidth`
+ // before the innermost latch runs. Portable Oniguruma only (no `{\N}` backref-as-count, no
+ // variable-length lookbehind): the dash level is `\G`-relative and self-recursive (one level per
+ // dash), and the explicit-N latch uses a LITERAL `{N}` floor (one region per digit, as §2a‴).
+ //
+ // The dash level opens ONLY on a real block-scalar header — `(?:dash )*… key: … |/> (#|$)` — so a
+ // plain compact nest (`- - a`, `- - k: v`) never matches it and still falls to §2c #block-sequence.
+ // The level body self-includes (deeper dashes); its `bsHeaderIncs` scope the inline `key:`/anchor/tag
+ // on the header line FIRST (they match further LEFT than the latch, which is not `\G`-anchored), so by
+ // the time the cursor reaches the introducer the latch opens there; and #comment handles a dedented
+ // comment line (after the consuming `while` strips this level's indent, a line shallower than the
+ // content floor is a real comment).
+ const seqDash = detectBlockSequence(grammar)?.indicator;
+ const seqDashRe = seqDash ? escapeRegex(seqDash) : '';
+ // The leading-indicator class for the header lookahead (`-`/`?`): a compact item may be preceded by
+ // further sequence dashes or an explicit-key `?` before the `key: |` (`- ? k: |`). Derived from the
+ // compact indicators, same as the value-prefix elsewhere; falls back to the dash alone.
+ const seqLeadCls = (ind.compactIndicators ?? []).length ? compactCls : `[${seqDashRe}]`;
+ // The header lookahead a dash level requires: optional further compact indicators, then a key + `:`
+ // separator + optional node properties + the block-scalar introducer (auto-detect `intro`, or the
+ // explicit `introClass${bsDigitAlt(n)}`), then a blank/comment rest-of-line.
+ const seqHeader = (header: string) =>
+ `(?=(?:${seqLeadCls}[\\t ]+)*[^\\n]*?${kvSep}[\\t ]+${bsProp}${header}[\\t ]*(?:#|$))`;
+ // The innermost latch — IDENTICAL in shape to `bsIntroRule`: a whitespace-only `[\t ]*` lead-in (NOT
+ // `\G`-anchored) so it matches the `|`/`>` introducer AFTER `bsHeaderIncs` have scoped the inline
+ // header (`key:`/anchor/tag). Two flaws of a `\G`-anchored skip the no-`\G` form avoids: a `\G[^…]*`
+ // skip SWALLOWS `key:` as unscoped region body, and a `\G[\t ]*` (with `\G`) never fires at all,
+ // because after a sub-match (`#key`/`#punctuation`) vscode-textmate does NOT re-anchor `\G` to the
+ // post-sub-match position. Without `\G` the latch competes by LEFTMOST: `#key`/`#punctuation` (and a
+ // deeper `#selfKey` dash, which IS `\G`-anchored at the line start) all match further left, so the
+ // latch only wins once the cursor reaches the introducer. AUTO-DETECT (`intro`) runs the funky body
+ // (floors at the first content line, relative to the consuming `while`'s advanced `\G`); EXPLICIT
+ // (`|N`) uses a LITERAL `{N}` floor — ` {N}` admits a body line at exactly the floor (deeper/at-floor
+ // is content), `[\t ]*$` keeps blanks, and a SHALLOWER line (a dedented comment/sibling) releases it.
+ const seqLatchAuto = {
+ begin: `[\\t ]*(${intro})(?=[\\t ]*(?:#|$))([\\t ]*.*)`,
+ beginCaptures: { '1': { name: bsIndicator }, '2': { patterns: commentIncs } },
+ while: '\\G',
+ patterns: funkyBody(bsContent),
+ };
+ const seqLatchExplicit = (n: number) => ({
+ begin: `[\\t ]*(${introClass}${bsDigitAlt(n)})(?=[\\t ]*(?:#|$))([\\t ]*.*)`,
+ beginCaptures: { '1': { name: bsIndicator }, '2': { patterns: commentIncs } },
+ while: `\\G(?> {${n}}(?=[\\t ]|[\\t ]*${cmtLit}?)|[\\t ]*$)`,
+ patterns: [{ begin: '$', while: '\\G', contentName: bsContent }],
+ });
+ // EVERY compact-sequence block-scalar level carries the FULL latch set, because a single `- ` entry's
+ // mapping can mix indicators across its keys (`- aaa: |2` … ` bbb: |` — the §2a⁗ regression scope-gap
+ // caught: a per-indicator region opened by `|2` had only the `|2` latch, so the sibling `bbb: |`
+ // auto-scalar found no latch and fell to meta.stream). The EXPLICIT `|N` latches (digit 1-9) are
+ // listed FIRST so a `|N` key takes the precise `{N}` floor; the AUTO latch is the fallback for a plain
+ // `|`/`>`/`|-` (whose floor auto-detects from the first body line). Each latch keys on the block
+ // scalar's OWN indicator, independent of which key opened the enclosing dash level.
+ const seqLatches = [...Array.from({ length: 9 }, (_, i) => seqLatchExplicit(i + 1)), seqLatchAuto];
+ // The consuming dash-level region: `\G`-anchored (nests via the meta.stream `\G` re-anchor), opens on
+ // one compact dash whose line carries a block-scalar header, CONSUMES `\1[ \t]\3` each line (so `\G`
+ // advances by this level's width), and its body self-includes (deeper dash) + every latch + header
+ // includes + #comment. `selfKey` is its own repository key (for the self-include). The opener `header`
+ // is the AUTO `intro` (it admits `|`/`>`/`|N`), so ONE region handles all indicators; the body's
+ // ordered latches pick the right floor per key.
+ const emitSeqBlockScalar = (selfKey: string, header: string, latches: TmPattern[]): TmPattern => ({
+ begin: `\\G( *+)(${seqDashRe})([\\t ]+)${seqHeader(header)}`,
+ beginCaptures: { '2': { name: `punctuation.${langName}` } },
+ while: '\\G(?>\\1[\\t ]\\3|[\\t ]*$)',
+ patterns: [{ include: `#${selfKey}` }, ...latches, ...bsHeaderIncs, ...commentIncs],
+ });
// Expose the introducer / inner-rule / header-includes to §2b (the `? |` explicit-key variant).
bsIntro = intro;
bsFunkyIntroRule = bsIntroRule;
@@ -5065,23 +5217,22 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
const docMarkAlt = docMarkers.map(escapeRegex).join('|');
const docMark = `(?:${docMarkAlt})(?=[\\t ]|$)`;
repository[`${bsKey}-doc`] = {
- begin: `^()(?=(?:${docMark}[\\t ]+)?${intro}[\\t ]*(?:#|$))`,
+ // `^([\\t ]*)` (not `^()`) so a leading-whitespace root introducer (` | …`) still routes
+ // here — a `#`-led body line at column 0 is then block-scalar string, not a comment (#12/#15).
+ begin: `^([\\t ]*)(?=(?:${docMark}[\\t ]+)?${intro}[\\t ]*(?:#|$))`,
while: `\\G(?!${docMark})`,
patterns: [bsIntroRule(bsIndicator, bsContent), ...bsHeaderIncs],
};
topPatterns.push({ include: `#${bsKey}-doc` });
}
- // Sequence entry whose mapping VALUE is the block scalar (`- a: |` … ` b:`): bound siblings at the
- // KEY column, not the dash column, else the next entry key is swallowed. The begin consumes the
- // leading indent `\1` AND the dash + its trailing spaces `\3`, and the bound `\1[ \t]\3[ \t]` is
- // one column past the key. A pure-space backref (`\1`, `\3`) standing in for the dash column keeps
- // it portable (no literal `- ` backref, which would never match space-indented body lines).
- repository[`${bsKey}-seq`] = emitIndentRegion({
- lookahead: `(-)([ \\t]+)(?=(?:[-?][\\t ]+)*[^\\n]*?:[\\t ]+${bsProp}${intro}[\\t ]*(?:#|$))`,
- beginCaptures: { '2': { name: `punctuation.${langName}` } },
- cont: '\\1[ \\t]\\3[ \\t]',
- patterns: [bsIntroRule(bsIndicator, bsContent), ...bsHeaderIncs],
- });
+ // Sequence entry whose mapping VALUE is a block scalar (`- a: |` / `- a: |N` … ` b: …`): the §2a⁗
+ // consuming dash-level region. Each `- ` opens a `\G`-relative child carrying its column, so a COMPACT
+ // nest (`- - a: |`) accumulates the correct content indent through the recursion (the flat
+ // `\1[ \t]\3[ \t]`/`\1[ \t]\3 {N}` floors it replaces counted only ONE dash → over-painted depth ≥ 2,
+ // monogram#12 #14). ONE region opens on the AUTO `intro` (admits `|`/`>`/`|N`) and its body carries
+ // ALL latches (`seqLatches`: explicit `{N}` floors + auto fallback), so every key of the entry's
+ // mapping — even with mixed indicators — takes the right floor. Self-includes `#${bsKey}-seq`.
+ repository[`${bsKey}-seq`] = emitSeqBlockScalar(`${bsKey}-seq`, intro, seqLatches);
topPatterns.push({ include: `#${bsKey}-seq` });
// ── 2a‴. EXPLICIT-indent block scalars (`|N` / `>N`, monogram#12 #10) ──
@@ -5096,9 +5247,10 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// + an inner introducer rule that opens the body at the header EOL); only two things change: the
// `while` bound is `\1 {N}` (parent+N) instead of `\1[ \t]` (parent+1), and the inner rule paints
// the body via `contentName` instead of the funky auto-detect (the floor is already known). Emitted
- // for digits 1–9 in both value position (`key: |N`, nested, and doc-root `|N` / `--- |N` — `bsVp`
- // admits the optional `---` / key / properties) and sequence position (`- a: |N`, whose floor adds
- // the dash column via `\3` — same as `-seq`). Ranked above the auto-detect variants (scopeOrder).
+ // for digits 1–9 in VALUE position (`key: |N`, nested, and doc-root `|N` / `--- |N` — `bsVp` admits
+ // the optional `---` / key / properties). The SEQUENCE-position explicit floor (`- a: |N`) is no
+ // longer a separate region: it is the `seqLatchExplicit(n)` latch carried inside the unified §2a⁗
+ // `${bsKey}-seq` region above. Ranked above the auto-detect value variant (scopeOrder).
for (let n = 1; n <= 9; n++) {
repository[`${bsKey}-explicit-${n}`] = emitIndentRegion({
lookahead: `(?=${bsVp}${introClass}${bsDigitAlt(n)}[\\t ]*(?:#|$))`,
@@ -5106,13 +5258,6 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
patterns: [bsExplicitIntroRule(n), ...bsHeaderIncs],
});
topPatterns.push({ include: `#${bsKey}-explicit-${n}` });
- repository[`${bsKey}-explicit-seq-${n}`] = emitIndentRegion({
- lookahead: `(-)([ \\t]+)(?=(?:[-?][\\t ]+)*[^\\n]*?:[\\t ]+${bsProp}${introClass}${bsDigitAlt(n)}[\\t ]*(?:#|$))`,
- beginCaptures: { '2': { name: `punctuation.${langName}` } },
- cont: `\\1[ \\t]\\3 {${n}}`,
- patterns: [bsExplicitIntroRule(n), ...bsHeaderIncs],
- });
- topPatterns.push({ include: `#${bsKey}-explicit-seq-${n}` });
}
// ── 2a′. Multi-line PLAIN scalar continuation (monogram#12 §6/§7) ──
@@ -5163,6 +5308,11 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// a real key separator (`http://x` keeps its glued `:` → still plain content). Used as a NEGATIVE
// lookahead to bound the fold at the first sibling/comment line, matching the parser's foldedPlain.
const structAhead = `(?:${cmtLit}|${compactAlt}|${flowEx}*?${kvSep}(?:[\\t ]|$))`;
+ // Fold-RELEASE variant (drops the `-`/`?` compact arm from structAhead, like §2c's foldExclude):
+ // once an inline plain value has started, a strictly-deeper line (the `\\1[ \\t]+` already
+ // guarantees it) that begins with `-`/`?` is plain-scalar CONTENT (a multi-line fold), not a
+ // sibling node — only a comment or a real `key:` separator ends the fold. (monogram#12 AB8U.)
+ const foldRelease = `(?:${cmtLit}|${flowEx}*?${kvSep}(?:[\\t ]|$))`;
// ── VALUE-POSITION guard (the closed transform's hinge) ──
// The IR-derived value-positions (valuePositions): the structural introducers (`-`/`?`/`:`) that
// open an indented value block. A FOLD region must YIELD at a value-position — the indented block
@@ -5255,9 +5405,15 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
const continuationRule = { match: '\\G[\\t ]+(?:[^#\\n]|#(?<=[^\\t\\n\\f\\r ]#))*', name: plainContent };
// Emitted only when the grammar actually has a DEEPER fold (`Indent … Dedent`).
if (fold.hasDeeper) {
+ // An explicit key whose value is a block sequence (`? - x` on one line) is NOT a foldable
+ // plain scalar — the `-` is a sequence item indicator the #block-sequence region must claim.
+ // Guard the plain fold from opening on that head (both indicators are grammar-derived, so the
+ // six non-indent grammars regenerate byte-identical). (monogram#12 M5DY.)
+ const ekInd = detectExplicitKey(grammar)?.indicator, seqInd = detectBlockSequence(grammar)?.indicator;
+ const seqInKeyGuard = (ekInd && seqInd) ? `(?!${escapeRegex(ekInd)}[\\t ]+${escapeRegex(seqInd)}[\\t ])` : '';
repository['plain-continuation'] = emitIndentRegion({
- lookahead: `(?=${plainVp})`,
- cont: `\\1[ \\t]+(?!${structAhead})`,
+ lookahead: `(?=${seqInKeyGuard}${plainVp})`,
+ cont: `\\1[ \\t]+(?!${foldRelease})`,
blankFirst: true,
patterns: [continuationRule, ...plainHeaderIncs],
});
@@ -5285,7 +5441,7 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// the guard is the explicit-key instance of "a fold yields to a value-position".
repository['explicit-key-continuation'] = emitIndentRegion({
lookahead: `(?=${escapeRegex(ekFold.indicator)}[\\t ]+(?=${plainSrc})${keyColonGuard})`,
- cont: `\\1[ \\t]+(?!${structAhead})`,
+ cont: `\\1[ \\t]+(?!${foldRelease})`,
blankFirst: true,
patterns: [ekContRule, ...plainHeaderIncs],
});
@@ -5342,55 +5498,43 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// indicator's column, which no `\1`-relative backref can express (the prefix is `- `, not spaces) and
// no possessive `[ \t]++` can split from the deeper-fold case `x: y\n - b` (same line, must fold).
//
- // The fix mirrors the maintained RedCMD YAML grammar's block-sequence: a `\G`-anchored region whose
- // rule stack carries the indent depth, RE-OPENED per compact level (its body self-includes
- // #block-sequence, so `- - - a` nests three deep). The meta.stream wrapper re-anchors `\G` at every
- // line, so each level's captures pin ITS OWN inner indicator column and reclaim only siblings AT that
- // column. We emit it ONLY for the COMPACT case (a dash followed by ANOTHER dash on the same line) —
- // `begin … (?=([\t ]+)${dash}[\t ])` — so a single `- a`, a `- key: v` mapping item, a `- {…}`/`- "…"`/
- // `- |` value, etc. are UNTOUCHED (still handled by the top-level token includes + the §2a′ fold),
- // confining this region to exactly the bug's shape. The compact re-anchor `(?=((?<=${reanchor}) )?+)`
- // (a FIXED-width lookbehind — portable, unlike RedCMD's variable-length `(?\1[\t ]\3|[\t ]*$)` consumes
+ // this level's width (indent + the dash's own column + the run) on each continuation line, or stays on
+ // a blank line. The continuation cursor, after all stacked frames consume, lands at exactly the inner
+ // node column.
//
- // A deeper line that is NOT a nested sibling folds into the item's plain scalar: the body's
- // #block-fold rule (`^([\t ]+)(?=[^\t\r\n#])(plain run)`, anchored at LINE START so it never fires on
- // the header line's inline inner item, which sits past column 0) scopes it `string.unquoted`. So
- // `- - a\n - b` (`[["a - b"]]` — the deeper `- b` folds) is `string`, while `- - a\n - b` and
- // `- - - a\n - b` (a same-column sibling at the inner OR a deeper-nested level) stay `punctuation`.
- // This resolves monogram#24's deeper-irregular residual without a variable-length lookbehind.
+ // RECLAIM vs FOLD falls out of the consume — no per-column lookahead, no saturating reconstruction.
+ // A continuation line whose indent the stacked whiles fully consume leaves `\G` AT a dash (a
+ // same-column sibling): the body scopes it `punctuation`. A line STRICTLY DEEPER leaves residual
+ // leading whitespace at the carried `\G`, which the body's #block-fold — re-anchored from `^` to `\G`
+ // so it tests the CARRIED mid-line cursor, not line start — folds to `string.unquoted` (a plain-scalar
+ // continuation). This `\G`-coupling is what splits the oracle-opposite pair the old saturated single
+ // column could not: after `- - - - a` (d=4, 3 consuming frames carry to col 6) a sibling at col 8 has
+ // residual whitespace → fold; after `- - - - - a` (d=5, 4 frames carry to col 8) the col-8 dash sits
+ // AT the carried cursor → punctuation. Both are correct at every depth because the carry is per-level
+ // recursive, not a fixed-arity formula (verified d=1..12, uniform and mixed compaction, vs the eemeli
+ // CST oracle — test/yaml-deepest-sibling-probe.ts). A sibling-opened multi-line nest
+ // (`- - a\n - - b\n - c`) works the same way: each line re-anchors via the meta.stream wrapper and
+ // the consume carries its column. The region RELEASES on a dedent or a non-dash line at the column, so
+ // a column-0 `key:` after the sequence is not swallowed. Portable Oniguruma only — no variable-length
+ // lookbehind (RedCMD's `(?\1[\t ]\3|[\t ]*$)` consumes that same width each
+ // continuation line, carrying the column by CONSUMPTION (no `\1\2 \4` reconstruction to saturate).
+ // A fully-consumed line lands `\G` AT a sibling dash (body → punctuation); a strictly-deeper line
+ // keeps residual whitespace there (body's `\G`-anchored #block-fold → string); a blank line stays.
repository['block-sequence'] = {
- begin: `(?=((?<=${reanchor}) )?+)\\G( *+)(${dash})(?=([\\t ]+)${dash}[\\t ])`,
- beginCaptures: { '3': { name: `punctuation.${langName}` } },
- while: `\\G(?>(?=\\1\\2 \\4${dash}[\\t ]+${dash}[\\t ])|(\\1\\2 \\4)(?=${dash}[\\t ]|${dash}$)|(?=\\1\\2 \\4[\\t ])|[\\t ]*$)`,
+ begin: `\\G( *+)(${dash})([\\t ]+)(?=${dash}[\\t ])`,
+ beginCaptures: { '2': { name: `punctuation.${langName}` } },
+ while: `\\G(?>\\1[\\t ]\\3|[\\t ]*$)`,
patterns: [],
};
// ── A block-mapping VALUE introduced by `${kvSep}`-at-EOL, INSIDE a compact item (`- key:` then an
@@ -5455,7 +5597,7 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// #block-sequence instead of folding. (monogram#24 deeper residual.)
const foldExclude = `(?:${cmtLit}|${flowEx}*?${kvSep}(?:[\\t ]|$))`;
repository['block-fold'] = {
- match: `^([\\t ]+)(?=[^\\t\\r\\n${cmtCc}])(?!${foldExclude})((?:[^${cmtCc}\\n]|${cmtLit}(?<=[^\\t\\n\\f\\r ]${cmtLit}))*)`,
+ match: `\\G([\\t ]+)(?=[^\\t\\r\\n${cmtCc}])(?!${foldExclude})((?:[^${cmtCc}\\n]|${cmtLit}(?<=[^\\t\\n\\f\\r ]${cmtLit}))*)`,
captures: { '2': { name: plainContent } },
};
topPatterns.push({ include: '#block-sequence' });
@@ -6424,8 +6566,7 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// line, the whole type-param list (which may then close on a later line)
// is scoped; the begin/end persists across lines until the matching `>`.
if (angleBracket && angleDisambig) {
- const balancedAngles = angleDisambig.balancedAngles;
- const arrowParamShape = angleDisambig.arrowParamShape;
+ const arrowEndConfirm = angleDisambig.arrowEndConfirm;
const arrowPos = `(?:(?<=\\basync\\s)|${notAfterValueWithOptionalWhitespace('\\w$)\\]}')})`;
// JSX-dialect disambiguator: in a `.tsx`/`.jsx` grammar a bare `(…`
// is a JSX element, so a generic-arrow type-param list is only recognised
@@ -6445,7 +6586,7 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
const topComma = jsx ? `(?=${angleDisambig.topTypeParam})` : '';
repository['arrow-type-parameters'] = {
name: `meta.type.parameters.${langName}`,
- begin: `${arrowPos}(<)${topComma}(?=${balancedAngles}>\\s*${arrowParamShape})`,
+ begin: `${arrowPos}(<)${topComma}(?=${arrowEndConfirm})`,
beginCaptures: {
'1': { name: `punctuation.definition.typeparameters.begin.${langName}` },
},
@@ -6468,7 +6609,7 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// meta.parameters.arrow); the wrapper is unnamed. Same trigger position (and -7 rank)
// as the old top-level #arrow-type-parameters, so all angle-bracket precedence holds.
repository['generic-arrow-function'] = {
- begin: `${arrowPos}(?=<${topComma}${balancedAngles}>\\s*${arrowParamShape})`,
+ begin: `${arrowPos}(?=<${topComma}${arrowEndConfirm})`,
end: '(?<=\\))',
patterns: [
{ include: '#arrow-type-parameters' },
@@ -8067,12 +8208,11 @@ export function generateTmLanguage(grammar: CstGrammar, langName: string): TmGra
// • the plain `blockscalar` is the fallback (bare `|`, `key: |`, `--- |` with an indented body).
const bsRank = grammar.indent?.blockScalar?.token.toLowerCase();
// EXPLICIT-indent block scalars (`|N`, §2a‴) must out-rank their auto-detect counterparts so a
- // `|N` header takes the digit-aware floor. The sequence variant (`- a: |N`) ranks above the value
- // variant: a `- …: |N` line matches BOTH (the value `bsVp` admits a leading `- `), and only the
- // sequence floor adds the dash column, so it must win. Both stay below `blockscalar-key` (0.55) so a
- // `? |N` explicit-key block scalar still scopes its `?` as the map key. (`-explicit-seq-` is tested
- // before `-explicit-` because the seq keys also start with the value prefix.)
- if (bsRank && key.startsWith(`${bsRank}-explicit-seq-`)) return 0.45;
+ // `|N` header takes the digit-aware floor. The unified sequence region (`${bsRank}-seq`, §2a⁗) ranks
+ // above the value `-explicit-` variant: a `- …: |N` line matches BOTH (the value `bsVp` admits a
+ // leading `- `), and only the sequence region carries the dash column, so it must win. It stays below
+ // `blockscalar-key` (0.55) so a `? |N` explicit-key block scalar still scopes its `?` as the map key
+ // (and `-seq` requires a leading dash its lookahead forbids for `? |`, so they never truly collide).
if (bsRank && key.startsWith(`${bsRank}-explicit-`)) return 0.57;
if (bsRank && key === `${bsRank}-seq`) return 0.5;
if (key === 'blockscalar-key') return 0.55;
diff --git a/src/types.ts b/src/types.ts
index 4b490fe..2377b08 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -98,6 +98,19 @@ export interface RegexContext {
export interface RawEmbed {
default: string; // embed scope when no (or an unlisted) lang= attribute
lang?: Record; // lang attribute value → embed scope (e.g. { ts: 'source.ts' })
+ // Whether the embedded language can swallow the close tag mid-line or leave an open construct at
+ // the close that misreads it — i.e. whether the body must FORCE-CLOSE mid-line and FORCE-UNWIND an
+ // open embedded region at the close tag. TRUE for `` on one line must
+ // still close — tmbundle#85; an unterminated `type T =` must unwind before `` is read as
+ // type-args — #5538/#2060): the body uses a `begin/while` open region whose `.*` drops at the first
+ // line CONTAINING the close, plus separate close-LINE rules. That `while` drop is what makes a non-
+ // first DIALECT's close-line content land on a lang-INDEPENDENT close rule (only the first fires),
+ // so a multi-dialect `forceClose` embed cannot keep per-dialect close lines — script accepts this
+ // (mid-line force-close is the priority for JS). FALSE (the default for a `{ default, lang }` embed)
+ // is for a well-behaved embed like CSS — no greedy line-comment swallows ``, nothing leaves
+ // an open construct — so the body uses a lookahead-`end` region (matching the official Vue grammar):
+ // the embed stays active up to `` cliff lived.
+//
+// Two structural checks over the GENERATED typescript/typescriptreact/javascript/javascriptreact
+// grammars, so a new construct cannot be added without this gate seeing it:
+//
+// PART 1 — DEPTH SWEEP (self-baselining). The angle-bracket disambiguations (generic call, type
+// cast, generic arrow, JSX tag type-args, generic type) confirm `<…>` is a type span. A confirm
+// built on an Oniguruma `\g<>` subroutine has a ~20-level recursion cap, so a deep nested generic
+// flips the discriminating scope at d=20 (the cast did exactly this: `<` → relational at d=20).
+// For each construct we sweep d=1,5,19,20,24,30 and assert the probe token's scope at every depth
+// EQUALS its shallow (d=1) value — a flip anywhere is a depth cliff. Self-baselining, so it is
+// robust to scope renames; it would have caught the cast cliff (gen-tm 1967) and the TSX arrow
+// cliff (the formerly-recursive arrowEndConfirm) before they shipped.
+//
+// PART 2 — `\g<>` CENSUS. Every Oniguruma subroutine `\g<>` reachable from a begin/match/while/end
+// in the emitted grammars is enumerated and matched against an ALLOWLIST of graceful-degraders
+// (a `\g<>` inside a negative lookahead or an optional group, whose overflow is benign). A `\g<>`
+// NOT on the list is a latent sole-confirmer cliff → FAIL, forcing a flat-confirm migration (as
+// done for generic-call/arrow/cast) or an explicit, depth-probed allowlist entry. This makes the
+// cast-cliff class structurally un-missable: it walks the EMITTED output, not a hand list.
+//
+// Run (bare node): node test/angle-depth-probe.ts · Exit 0 iff no cliff AND census clean.
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import vsctm from 'vscode-textmate';
+import onig from 'vscode-oniguruma';
+
+const { INITIAL, Registry } = vsctm;
+const { loadWASM, OnigScanner, OnigString } = onig;
+const require = createRequire(import.meta.url);
+const wasm = readFileSync(require.resolve('vscode-oniguruma/release/onig.wasm'));
+await loadWASM(wasm.buffer.slice(wasm.byteOffset, wasm.byteOffset + wasm.byteLength));
+
+async function load(path: string) {
+ const raw = JSON.parse(readFileSync(path, 'utf8'));
+ const reg = new Registry({
+ onigLib: Promise.resolve({
+ createOnigScanner: (ps: string[]) => new OnigScanner(ps),
+ createOnigString: (s: string) => new OnigString(s),
+ }),
+ loadGrammar: async (scope: string) => (scope === raw.scopeName ? raw : null),
+ });
+ return reg.loadGrammar(raw.scopeName);
+}
+
+const TS = await load('./typescript.tmLanguage.json');
+const TSX = await load('./typescriptreact.tmLanguage.json');
+
+// scope of the FIRST token whose text === `needle` (optionally the nth), innermost scope.
+function scopeOf(g: any, src: string, needle: string, nth = 1): string | null {
+ const lines = src.split('\n');
+ let rs = INITIAL;
+ let seen = 0;
+ for (const line of lines) {
+ const r = g.tokenizeLine(line, rs);
+ for (const t of r.tokens) {
+ if (line.slice(t.startIndex, t.endIndex) === needle && ++seen === nth) return t.scopes[t.scopes.length - 1];
+ }
+ rs = r.ruleStack;
+ }
+ return null;
+}
+
+// A d-deep nested generic type span: A0…>> (no spaces, the densest form).
+const nest = (d: number) => {
+ let s = 'X';
+ for (let i = 0; i < d; i++) s = `A${i}<${s}>`;
+ return s;
+};
+
+interface Construct {
+ name: string;
+ g: any;
+ build: (d: number) => string;
+ needle: string; // token whose scope must stay stable across depth
+ nth?: number;
+}
+
+const CONSTRUCTS: Construct[] = [
+ { name: 'generic-call (ts)', g: TS, build: (d) => `const z = f<${nest(d)}>(0);\n`, needle: '<' },
+ { name: 'type-cast (ts)', g: TS, build: (d) => `const x = <${nest(d)}>v;\n`, needle: '<' },
+ { name: 'generic-type-annotation (ts)', g: TS, build: (d) => `let a: ${nest(d)};\n`, needle: '<' },
+ { name: 'generic-arrow (tsx)', g: TSX, build: (d) => `const f = (p: T) => p;\n`, needle: 'p', nth: 1 },
+ { name: 'jsx-tag-type-args (tsx)', g: TSX, build: (d) => `const e = a={1} />;\n`, needle: 'Comp' },
+];
+
+const DEPTHS = [1, 5, 19, 20, 24, 30];
+const cliffs: string[] = [];
+
+for (const c of CONSTRUCTS) {
+ const baseline = scopeOf(c.g, c.build(1), c.needle, c.nth);
+ const row: string[] = [];
+ for (const d of DEPTHS) {
+ const sc = scopeOf(c.g, c.build(d), c.needle, c.nth);
+ const ok = sc === baseline;
+ row.push(`d${d}:${ok ? 'ok' : 'FLIP'}`);
+ if (!ok) cliffs.push(`${c.name} «${c.needle}» d=${d}: ${sc} (shallow was ${baseline})`);
+ }
+ console.log(` ${c.name.padEnd(30)} «${c.needle}»→${baseline}\n ${row.join(' ')}`);
+}
+
+// PART 2 — \g<> census over the emitted grammars.
+// Allowlist: a graceful-degrader is a `\g<>` whose overflow is benign — inside a NEGATIVE lookahead
+// (the bail-out just doesn't fire) or an OPTIONAL group (a flat fallback follows). Each entry names
+// the repository key + subroutine and WHY it is safe.
+const ALLOW: { grammar: RegExp; keyRe: RegExp; sub: string; why: string }[] = [
+ { grammar: /typescript(react)?/, keyRe: /generic-call-multiline/, sub: 'B', why: 'inside a NEGATIVE lookahead (?!…) — overflow makes the bail-out not fire (benign), verified stable to d=30' },
+ { grammar: /typescriptreact/, keyRe: /jsx/, sub: 'TA', why: 'inside an OPTIONAL group (?:…)? with a flat [^>]* fallback — overflow falls back to the region, verified stable to d=30' },
+];
+const census: string[] = [];
+const unrecognized: string[] = [];
+for (const [gf] of [['typescript.tmLanguage.json'], ['typescriptreact.tmLanguage.json'], ['javascript.tmLanguage.json'], ['javascriptreact.tmLanguage.json']] as const) {
+ const g = JSON.parse(readFileSync(`./${gf}`, 'utf8'));
+ const walk = (node: any, key: string) => {
+ if (!node || typeof node !== 'object') return;
+ for (const f of ['begin', 'match', 'while', 'end'] as const) {
+ const re = node[f];
+ if (typeof re === 'string') {
+ for (const m of re.matchAll(/\\g<([^>]*)>/g)) {
+ const sub = m[1];
+ census.push(`${gf}:${key}.${f}:\\g<${sub}>`);
+ const ok = ALLOW.some((a) => a.grammar.test(gf) && a.keyRe.test(key) && a.sub === sub);
+ if (!ok) unrecognized.push(`${gf} ${key}.${f} \\g<${sub}>`);
+ }
+ }
+ }
+ for (const k in node) if (k !== 'repository' && typeof node[k] === 'object') walk(node[k], key);
+ };
+ for (const k in (g.repository || {})) walk(g.repository[k], k);
+}
+
+console.log(`\n \\g<> census: ${census.length} subroutine use(s); ${unrecognized.length} unrecognized (not a known graceful-degrader)`);
+for (const u of unrecognized) console.log(` UNRECOGNIZED \\g<> (latent depth cliff — flat-migrate or allowlist with a depth-probe): ${u}`);
+
+const fail = cliffs.length + unrecognized.length;
+if (cliffs.length) { console.log('\n DEPTH CLIFFS:'); for (const c of cliffs) console.log(` ${c}`); }
+console.log(fail === 0
+ ? '\n✓ no angle-bracket depth cliff (stable to d=30) and \\g<> census clean'
+ : `\n✗ ${cliffs.length} cliff(s) + ${unrecognized.length} unrecognized \\g<>`);
+process.exit(fail === 0 ? 0 : 1);
diff --git a/test/check.ts b/test/check.ts
index 2c3081f..25184ad 100644
--- a/test/check.ts
+++ b/test/check.ts
@@ -34,6 +34,7 @@ const GATES: Gate[] = [
{ group: 'conformance', name: 'html', args: ['test/html-conformance.ts'] },
{ group: 'highlighter', name: 'tm-guards', args: ['test/tm-highlight-guards.ts'] },
{ group: 'highlighter', name: 'tm-diagnostics', args: ['test/redcmd-tm-diagnostics.ts'] },
+ { group: 'highlighter', name: 'angle-depth', args: ['test/angle-depth-probe.ts'] },
{ group: 'highlighter', name: 'html-monarch', args: ['test/html-monarch.ts'] },
{ group: 'highlighter', name: 'html-embed-js', args: ['test/html-embed-js.ts'] },
{ group: 'highlighter', name: 'html-lexer-spike', args: ['test/html-lexer-spike.ts'] },
@@ -41,6 +42,7 @@ const GATES: Gate[] = [
{ group: 'highlighter', name: 'raw-text-case-sites', args: ['test/raw-text-case-sites.ts'] },
{ group: 'vue', name: 'directives', args: ['test/vue-directives.ts'] },
{ group: 'vue', name: 'embed-boundary', args: ['test/vue-embed-boundary.ts'] },
+ { group: 'vue', name: 'raw-style-embed', args: ['test/vue-raw-style-embed-sites.ts'] },
{ group: 'vue', name: 'interp-expr', args: ['test/vue-interp-expr.ts'] },
{ group: 'core', name: 'indent-extensions', args: ['test/indent-extensions.ts'] },
{ group: 'yaml', name: 'issue12-regressions', args: ['test/yaml-issue12-regressions.ts'] },
@@ -48,6 +50,8 @@ const GATES: Gate[] = [
{ group: 'yaml', name: 'depth-sites', args: ['test/depth-sites.ts'] },
{ group: 'yaml', name: 'flow-sites', args: ['test/flow-sites.ts'] },
{ group: 'yaml', name: 'compact-nest-sites', args: ['test/compact-nest-sites.ts'] },
+ { group: 'yaml', name: 'deepest-sibling', args: ['test/yaml-deepest-sibling-probe.ts'] },
+ { group: 'yaml', name: 'blockscalar-depth', args: ['test/yaml-blockscalar-depth-probe.ts'] },
{ group: 'generative', name: 'scope≡role', args: ['test/generative.ts'] },
{ group: 'generative', name: 'gap-ledger-selftest', args: ['test/gap-ledger-selftest.ts'] },
{ group: 'generative', name: 'gap-ledger-check', args: ['test/gap-ledger.ts', '--check'] },
diff --git a/test/vue-raw-style-embed-sites.ts b/test/vue-raw-style-embed-sites.ts
new file mode 100644
index 0000000..031cabf
--- /dev/null
+++ b/test/vue-raw-style-embed-sites.ts
@@ -0,0 +1,70 @@
+// vue-raw-style-embed-sites.ts — an enumerator of the `), so every dialect's close rule shares one regex and only the first-
+// listed fires — a non-first dialect's CLOSE-LINE content (the pre-`` text) is then embedded
+// in the WRONG dialect. A bug is exactly: content that should be source.css.X carries some other
+// source.css.* instead.
+//
+// WHY THE EXISTING GATES MISSED IT (see issue #43 discussion): scope-gap-vue grades the Vue shell
+// (tags/directives/interpolation) against @vue/compiler-sfc+parse5+tsc — it has NO CSS oracle, so the
+// embedded dialect is structurally ungraded. This test adds that missing axis: an oracle that is the
+// grammar's DECLARED embed scope (not Monogram's parser, which raw-texts the body as a blob), and
+// DERIVED witnesses (each dialect × each structural position) rather than a thin corpus.
+//
+// CLOSED LOOP / no hardcoding: the dialects + their expected scopes come from the SAME grammar source
+// the emitter derives the rules from (`grammar.markup.rawText.embed.style`).
+//
+// Run: node test/vue-raw-style-embed-sites.ts
+import { tokenize } from './vue-grammar-harness.ts';
+import grammar from '../vue.ts';
+
+const style = (grammar as any).markup?.rawText?.embed?.style;
+if (!style) { console.error('vue grammar has no markup.rawText.embed.style'); process.exit(1); }
+
+// [langAttr | null (default), expectedScope]; closed-loop from the grammar's own embed map.
+const dialects: [string | null, string][] = [
+ [null, style.default],
+ ...Object.entries(style.lang as Record).map(([k, v]) => [k, v] as [string, string]),
+];
+
+// Structural positions. Each builds a `, find: 'midline' },
+ // THE BUG: content on the SAME line as the close `` — the per-dialect close rule's capture.
+ { pos: 'close-line ', src: `${open}\n.firstline { a: 1 }\n.closeline { b: 2 }`, find: 'closeline' },
+ // single-line: open, content, and close all on one line.
+ { pos: 'single-line ', src: `${open}.oneline { c: 3 }`, find: 'oneline' },
+ ];
+}
+
+const cssScope = (chain: string) => chain.split(' ').find(s => s.startsWith('source.css') || s === 'source.sass' || s === 'source.stylus' || s === 'source.postcss') ?? '(none)';
+
+let cells = 0, wrong = 0;
+const fails: string[] = [];
+for (const [lang, expected] of dialects) {
+ for (const w of witnesses(lang)) {
+ cells++;
+ const toks = await tokenize('mono', w.src);
+ const t = toks.find(x => x.text.includes(w.find));
+ const got = t ? cssScope(t.scopes) : '(token not found)';
+ const ok = t !== undefined && t.scopes.split(' ').includes(expected);
+ if (!ok) { wrong++; fails.push(`