meta_language/
parity.rs

1/// Capability tracked for comparison with existing language tooling.
2#[derive(Clone, Copy, Debug, PartialEq, Eq)]
3pub enum ParityCapability {
4    /// Preserve every byte of source text and source metadata.
5    LosslessParsing,
6    /// Preserve and explicitly attach trivia.
7    TriviaPreservation,
8    /// Produce recoverable error and missing links for invalid input.
9    ErrorRecovery,
10    /// Parse mixed-language documents as one links network.
11    MixedLanguageRegions,
12    /// Match syntax patterns with captures and predicates.
13    QueryMatching,
14    /// Transform the network with match-and-substitute rules.
15    TransformBySubstitution,
16    /// Reconstruct text in the same language without losing unchanged regions.
17    SameLanguageReconstruction,
18    /// Reconstruct text in a different language through shared concepts.
19    CrossLanguageReconstruction,
20    /// Round-trip ordinary host objects through LiNo-compatible links.
21    ObjectRoundTrip,
22    /// Evaluate type, meaning, and truth-value links.
23    SemanticEvaluation,
24    /// Formalize and deformalize text through shared meaning links.
25    FormalizationRoundTrip,
26    /// Describe the meta language with links in the same network.
27    SelfDescription,
28    /// Capture immutable snapshots, edit mutable forks, and commit versions.
29    SnapshotVersioning,
30}
31
32/// Upstream project whose feature set and tests should be tracked.
33#[derive(Clone, Copy, Debug, PartialEq, Eq)]
34pub struct ParityTarget {
35    name: &'static str,
36    upstream: &'static str,
37    capabilities: &'static [ParityCapability],
38    test_plan: &'static str,
39}
40
41impl ParityTarget {
42    /// Project name.
43    #[must_use]
44    pub const fn name(&self) -> &'static str {
45        self.name
46    }
47
48    /// Upstream project URL.
49    #[must_use]
50    pub const fn upstream(&self) -> &'static str {
51        self.upstream
52    }
53
54    /// Capabilities tracked for parity.
55    #[must_use]
56    pub const fn capabilities(&self) -> &'static [ParityCapability] {
57        self.capabilities
58    }
59
60    /// Test adoption plan for this project.
61    #[must_use]
62    pub const fn test_plan(&self) -> &'static str {
63        self.test_plan
64    }
65}
66
67/// Competitor and ecosystem projects called out by the founding issue.
68pub const PARITY_TARGETS: &[ParityTarget] = &[
69    ParityTarget {
70        name: "tree-sitter",
71        upstream: "https://github.com/tree-sitter/tree-sitter",
72        capabilities: &[
73            ParityCapability::LosslessParsing,
74            ParityCapability::ErrorRecovery,
75            ParityCapability::MixedLanguageRegions,
76            ParityCapability::QueryMatching,
77        ],
78        test_plan: "Executable fixture covers concrete syntax, injection, query, and recovery behavior.",
79    },
80    ParityTarget {
81        name: "LibCST",
82        upstream: "https://github.com/Instagram/LibCST",
83        capabilities: &[
84            ParityCapability::LosslessParsing,
85            ParityCapability::TriviaPreservation,
86            ParityCapability::SameLanguageReconstruction,
87        ],
88        test_plan: "Executable fixture covers Python parse, metadata, transform, and round-trip behavior.",
89    },
90    ParityTarget {
91        name: "Recast",
92        upstream: "https://github.com/benjamn/recast",
93        capabilities: &[
94            ParityCapability::LosslessParsing,
95            ParityCapability::TriviaPreservation,
96            ParityCapability::SameLanguageReconstruction,
97        ],
98        test_plan: "Executable fixture covers JavaScript/TypeScript parse-print preservation behavior.",
99    },
100    ParityTarget {
101        name: "jscodeshift",
102        upstream: "https://github.com/facebook/jscodeshift",
103        capabilities: &[
104            ParityCapability::QueryMatching,
105            ParityCapability::TransformBySubstitution,
106            ParityCapability::SameLanguageReconstruction,
107        ],
108        test_plan: "Executable fixture covers substitution-rule transform behavior.",
109    },
110    ParityTarget {
111        name: "Rowan",
112        upstream: "https://github.com/rust-analyzer/rowan",
113        capabilities: &[
114            ParityCapability::LosslessParsing,
115            ParityCapability::TriviaPreservation,
116            ParityCapability::SameLanguageReconstruction,
117            ParityCapability::SnapshotVersioning,
118        ],
119        test_plan: "Executable fixture covers persistent syntax and trivia preservation behavior.",
120    },
121    ParityTarget {
122        name: "cstree",
123        upstream: "https://github.com/domenicquirl/cstree",
124        capabilities: &[
125            ParityCapability::LosslessParsing,
126            ParityCapability::TriviaPreservation,
127            ParityCapability::SameLanguageReconstruction,
128            ParityCapability::SnapshotVersioning,
129        ],
130        test_plan: "Executable fixture covers Rust concrete syntax and checkpoint behavior.",
131    },
132    ParityTarget {
133        name: "Roslyn",
134        upstream: "https://github.com/dotnet/roslyn",
135        capabilities: &[
136            ParityCapability::LosslessParsing,
137            ParityCapability::TriviaPreservation,
138            ParityCapability::ErrorRecovery,
139            ParityCapability::SameLanguageReconstruction,
140        ],
141        test_plan: "Executable fixture covers C# syntax, trivia, diagnostics, and formatting behavior.",
142    },
143    ParityTarget {
144        name: "links-notation",
145        upstream: "https://github.com/link-foundation/links-notation",
146        capabilities: &[
147            ParityCapability::LosslessParsing,
148            ParityCapability::ObjectRoundTrip,
149            ParityCapability::SelfDescription,
150        ],
151        test_plan: "Executable fixture covers doublet, triplet, N-tuple, and indented LiNo behavior.",
152    },
153    ParityTarget {
154        name: "link-cli",
155        upstream: "https://github.com/link-foundation/link-cli",
156        capabilities: &[ParityCapability::TransformBySubstitution],
157        test_plan: "Executable fixture covers create, update, delete, swap, trigger, and dedup substitution behavior.",
158    },
159    ParityTarget {
160        name: "lino-objects-codec",
161        upstream: "https://github.com/link-foundation/lino-objects-codec",
162        capabilities: &[ParityCapability::ObjectRoundTrip],
163        test_plan: "Executable fixture covers encode/decode, identity, shared-reference, and circular-reference behavior.",
164    },
165    ParityTarget {
166        name: "relative-meta-logic",
167        upstream: "https://github.com/link-foundation/relative-meta-logic",
168        capabilities: &[
169            ParityCapability::SemanticEvaluation,
170            ParityCapability::SelfDescription,
171        ],
172        test_plan: "Executable fixture covers dependent-type, many-valued, probabilistic, and paradox behavior.",
173    },
174    ParityTarget {
175        name: "formal-ai",
176        upstream: "https://github.com/link-assistant/formal-ai",
177        capabilities: &[
178            ParityCapability::FormalizationRoundTrip,
179            ParityCapability::SemanticEvaluation,
180            ParityCapability::CrossLanguageReconstruction,
181        ],
182        test_plan: "Executable fixture covers formalization corpus and cross-language reconstruction behavior.",
183    },
184    ParityTarget {
185        name: "meta-expression",
186        upstream: "https://github.com/link-assistant/meta-expression",
187        capabilities: &[
188            ParityCapability::FormalizationRoundTrip,
189            ParityCapability::TriviaPreservation,
190            ParityCapability::CrossLanguageReconstruction,
191        ],
192        test_plan: "Executable fixture covers formalize, semantic-link, naturalize, span, and self-reference behavior.",
193    },
194];
195
196/// Executable source fixture tied to a parity target.
197#[derive(Clone, Copy, Debug, PartialEq, Eq)]
198pub struct ParityFixture {
199    target_name: &'static str,
200    name: &'static str,
201    language: &'static str,
202    source: &'static str,
203    expected_reconstruction: &'static str,
204    capabilities: &'static [ParityCapability],
205}
206
207impl ParityFixture {
208    /// Target project name.
209    #[must_use]
210    pub const fn target_name(&self) -> &'static str {
211        self.target_name
212    }
213
214    /// Fixture name.
215    #[must_use]
216    pub const fn name(&self) -> &'static str {
217        self.name
218    }
219
220    /// Source language label used by the parser.
221    #[must_use]
222    pub const fn language(&self) -> &'static str {
223        self.language
224    }
225
226    /// Source text exercised by the fixture.
227    #[must_use]
228    pub const fn source(&self) -> &'static str {
229        self.source
230    }
231
232    /// Expected lossless reconstruction.
233    #[must_use]
234    pub const fn expected_reconstruction(&self) -> &'static str {
235        self.expected_reconstruction
236    }
237
238    /// Capabilities exercised by this fixture.
239    #[must_use]
240    pub const fn capabilities(&self) -> &'static [ParityCapability] {
241        self.capabilities
242    }
243
244    /// Parity target for this fixture.
245    #[must_use]
246    pub fn target(&self) -> &'static ParityTarget {
247        PARITY_TARGETS
248            .iter()
249            .find(|target| target.name() == self.target_name)
250            .expect("parity fixture target must exist")
251    }
252}
253
254/// Executable fixtures for every parity target called out by the founding issue.
255pub const PARITY_FIXTURES: &[ParityFixture] = &[
256    ParityFixture {
257        target_name: "tree-sitter",
258        name: "markdown fenced rust with queryable tokens",
259        language: "Markdown",
260        source: "Intro\n```rust\nfn main() {}\n```\n",
261        expected_reconstruction: "Intro\n```rust\nfn main() {}\n```\n",
262        capabilities: &[
263            ParityCapability::LosslessParsing,
264            ParityCapability::ErrorRecovery,
265            ParityCapability::MixedLanguageRegions,
266            ParityCapability::QueryMatching,
267        ],
268    },
269    ParityFixture {
270        target_name: "LibCST",
271        name: "python round trip with indentation",
272        language: "Python",
273        source: "def f(x):\n    return x + 1\n",
274        expected_reconstruction: "def f(x):\n    return x + 1\n",
275        capabilities: &[
276            ParityCapability::LosslessParsing,
277            ParityCapability::TriviaPreservation,
278            ParityCapability::SameLanguageReconstruction,
279        ],
280    },
281    ParityFixture {
282        target_name: "Recast",
283        name: "javascript comment preservation",
284        language: "JavaScript",
285        source: "const value = 1; // keep trivia\n",
286        expected_reconstruction: "const value = 1; // keep trivia\n",
287        capabilities: &[
288            ParityCapability::LosslessParsing,
289            ParityCapability::TriviaPreservation,
290            ParityCapability::SameLanguageReconstruction,
291        ],
292    },
293    ParityFixture {
294        target_name: "jscodeshift",
295        name: "javascript transform input",
296        language: "JavaScript",
297        source: "const oldName = call(oldName);\n",
298        expected_reconstruction: "const oldName = call(oldName);\n",
299        capabilities: &[
300            ParityCapability::QueryMatching,
301            ParityCapability::TransformBySubstitution,
302            ParityCapability::SameLanguageReconstruction,
303        ],
304    },
305    ParityFixture {
306        target_name: "Rowan",
307        name: "rust trivia preservation",
308        language: "Rust",
309        source: "fn main() {\n    // keep\n}\n",
310        expected_reconstruction: "fn main() {\n    // keep\n}\n",
311        capabilities: &[
312            ParityCapability::LosslessParsing,
313            ParityCapability::TriviaPreservation,
314            ParityCapability::SameLanguageReconstruction,
315            ParityCapability::SnapshotVersioning,
316        ],
317    },
318    ParityFixture {
319        target_name: "cstree",
320        name: "rust checkpoint source",
321        language: "Rust",
322        source: "let checkpoint = value + 1;\n",
323        expected_reconstruction: "let checkpoint = value + 1;\n",
324        capabilities: &[
325            ParityCapability::LosslessParsing,
326            ParityCapability::TriviaPreservation,
327            ParityCapability::SameLanguageReconstruction,
328            ParityCapability::SnapshotVersioning,
329        ],
330    },
331    ParityFixture {
332        target_name: "Roslyn",
333        name: "csharp diagnostic recovery source",
334        language: "C#",
335        source: "class C { void M() { Console.WriteLine(1); } }\n",
336        expected_reconstruction: "class C { void M() { Console.WriteLine(1); } }\n",
337        capabilities: &[
338            ParityCapability::LosslessParsing,
339            ParityCapability::TriviaPreservation,
340            ParityCapability::ErrorRecovery,
341            ParityCapability::SameLanguageReconstruction,
342        ],
343    },
344    ParityFixture {
345        target_name: "links-notation",
346        name: "lino tuple forms",
347        language: "LiNo",
348        source: "(lovesMama: loves mama)\npapa has car\n",
349        expected_reconstruction: "(lovesMama: loves mama)\npapa has car\n",
350        capabilities: &[
351            ParityCapability::LosslessParsing,
352            ParityCapability::ObjectRoundTrip,
353            ParityCapability::SelfDescription,
354        ],
355    },
356    ParityFixture {
357        target_name: "link-cli",
358        name: "substitution patterns",
359        language: "LiNo",
360        source: "((1: 1 1)) ((1: 1 2))\n",
361        expected_reconstruction: "((1: 1 1)) ((1: 1 2))\n",
362        capabilities: &[ParityCapability::TransformBySubstitution],
363    },
364    ParityFixture {
365        target_name: "lino-objects-codec",
366        name: "shared and circular references",
367        language: "LiNo",
368        source: "(object: object object)\n(shared: object object)\n",
369        expected_reconstruction: "(object: object object)\n(shared: object object)\n",
370        capabilities: &[ParityCapability::ObjectRoundTrip],
371    },
372    ParityFixture {
373        target_name: "relative-meta-logic",
374        name: "dependent type and paradox source",
375        language: "RML",
376        source: "(Type: Type Type)\n(this_statement_is_false)\n",
377        expected_reconstruction: "(Type: Type Type)\n(this_statement_is_false)\n",
378        capabilities: &[
379            ParityCapability::SemanticEvaluation,
380            ParityCapability::SelfDescription,
381        ],
382    },
383    ParityFixture {
384        target_name: "formal-ai",
385        name: "formalization reconstruction source",
386        language: "English",
387        source: "Hawaii is a state.\n",
388        expected_reconstruction: "Hawaii is a state.\n",
389        capabilities: &[
390            ParityCapability::FormalizationRoundTrip,
391            ParityCapability::SemanticEvaluation,
392            ParityCapability::CrossLanguageReconstruction,
393        ],
394    },
395    ParityFixture {
396        target_name: "meta-expression",
397        name: "naturalization span source",
398        language: "English",
399        source: "1 + 1 = 2\n",
400        expected_reconstruction: "1 + 1 = 2\n",
401        capabilities: &[
402            ParityCapability::FormalizationRoundTrip,
403            ParityCapability::TriviaPreservation,
404            ParityCapability::CrossLanguageReconstruction,
405        ],
406    },
407];
408
409/// Family of language coverage targets.
410#[derive(Clone, Copy, Debug, PartialEq, Eq)]
411pub enum LanguageFamily {
412    /// Markup or document container languages.
413    Markup,
414    /// Programming languages.
415    Programming,
416    /// Natural languages.
417    Natural,
418}
419
420/// Language whose grammar or natural-language parser should be supported.
421#[derive(Clone, Copy, Debug, PartialEq, Eq)]
422pub struct LanguageTarget {
423    name: &'static str,
424    family: LanguageFamily,
425    basis: &'static str,
426}
427
428impl LanguageTarget {
429    /// Language name.
430    #[must_use]
431    pub const fn name(&self) -> &'static str {
432        self.name
433    }
434
435    /// Language family.
436    #[must_use]
437    pub const fn family(&self) -> LanguageFamily {
438        self.family
439    }
440
441    /// Basis for including this target.
442    #[must_use]
443    pub const fn basis(&self) -> &'static str {
444        self.basis
445    }
446}
447
448/// Executable lossless parse fixture for a required language target.
449#[derive(Clone, Copy, Debug, PartialEq, Eq)]
450pub struct LanguageFixture {
451    language: &'static str,
452    source: &'static str,
453    description: &'static str,
454}
455
456impl LanguageFixture {
457    /// Language label used by the parser.
458    #[must_use]
459    pub const fn language(&self) -> &'static str {
460        self.language
461    }
462
463    /// Source text that must parse and reconstruct losslessly.
464    #[must_use]
465    pub const fn source(&self) -> &'static str {
466        self.source
467    }
468
469    /// Behavior represented by this fixture.
470    #[must_use]
471    pub const fn description(&self) -> &'static str {
472        self.description
473    }
474}
475
476/// Required document-container languages.
477pub const MARKUP_LANGUAGE_TARGETS: &[LanguageTarget] = &[
478    LanguageTarget {
479        name: "txt",
480        family: LanguageFamily::Markup,
481        basis: "Issue #5 degenerate plain-text container target",
482    },
483    LanguageTarget {
484        name: "Markdown",
485        family: LanguageFamily::Markup,
486        basis: "Founding issue full-document target",
487    },
488    LanguageTarget {
489        name: "HTML",
490        family: LanguageFamily::Markup,
491        basis: "Founding issue full-document target",
492    },
493];
494
495/// Initial top-ten programming-language parser targets.
496pub const PROGRAMMING_LANGUAGE_TARGETS: &[LanguageTarget] = &[
497    LanguageTarget {
498        name: "Python",
499        family: LanguageFamily::Programming,
500        basis: "TIOBE May 2026 top 10",
501    },
502    LanguageTarget {
503        name: "C",
504        family: LanguageFamily::Programming,
505        basis: "TIOBE May 2026 top 10",
506    },
507    LanguageTarget {
508        name: "Java",
509        family: LanguageFamily::Programming,
510        basis: "TIOBE May 2026 top 10",
511    },
512    LanguageTarget {
513        name: "C++",
514        family: LanguageFamily::Programming,
515        basis: "TIOBE May 2026 top 10",
516    },
517    LanguageTarget {
518        name: "C#",
519        family: LanguageFamily::Programming,
520        basis: "TIOBE May 2026 top 10",
521    },
522    LanguageTarget {
523        name: "JavaScript",
524        family: LanguageFamily::Programming,
525        basis: "TIOBE May 2026 top 10",
526    },
527    LanguageTarget {
528        name: "Visual Basic",
529        family: LanguageFamily::Programming,
530        basis: "TIOBE May 2026 top 10",
531    },
532    LanguageTarget {
533        name: "R",
534        family: LanguageFamily::Programming,
535        basis: "TIOBE May 2026 top 10",
536    },
537    LanguageTarget {
538        name: "SQL",
539        family: LanguageFamily::Programming,
540        basis: "TIOBE May 2026 top 10",
541    },
542    LanguageTarget {
543        name: "Delphi/Object Pascal",
544        family: LanguageFamily::Programming,
545        basis: "TIOBE May 2026 top 10",
546    },
547];
548
549/// Initial top-ten natural-language parser targets by total speakers.
550pub const NATURAL_LANGUAGE_TARGETS: &[LanguageTarget] = &[
551    LanguageTarget {
552        name: "English",
553        family: LanguageFamily::Natural,
554        basis: "Ethnologue/Britannica total-speaker top 10",
555    },
556    LanguageTarget {
557        name: "Mandarin Chinese",
558        family: LanguageFamily::Natural,
559        basis: "Ethnologue/Britannica total-speaker top 10",
560    },
561    LanguageTarget {
562        name: "Hindi",
563        family: LanguageFamily::Natural,
564        basis: "Ethnologue/Britannica total-speaker top 10",
565    },
566    LanguageTarget {
567        name: "Spanish",
568        family: LanguageFamily::Natural,
569        basis: "Ethnologue/Britannica total-speaker top 10",
570    },
571    LanguageTarget {
572        name: "French",
573        family: LanguageFamily::Natural,
574        basis: "Ethnologue/Britannica total-speaker top 10",
575    },
576    LanguageTarget {
577        name: "Modern Standard Arabic",
578        family: LanguageFamily::Natural,
579        basis: "Ethnologue/Britannica total-speaker top 10",
580    },
581    LanguageTarget {
582        name: "Bengali",
583        family: LanguageFamily::Natural,
584        basis: "Ethnologue/Britannica total-speaker top 10",
585    },
586    LanguageTarget {
587        name: "Russian",
588        family: LanguageFamily::Natural,
589        basis: "Ethnologue/Britannica total-speaker top 10",
590    },
591    LanguageTarget {
592        name: "Portuguese",
593        family: LanguageFamily::Natural,
594        basis: "Ethnologue/Britannica total-speaker top 10",
595    },
596    LanguageTarget {
597        name: "Urdu",
598        family: LanguageFamily::Natural,
599        basis: "Ethnologue/Britannica total-speaker top 10",
600    },
601];
602
603/// Executable fixtures for every language target requested by the founding issue.
604pub const LANGUAGE_FIXTURES: &[LanguageFixture] = &[
605    LanguageFixture {
606        language: "txt",
607        source: "Plain text region\ncafe au lait\nUTF-8 line: café\n",
608        description: "Plain-text UTF-8 prose with trailing newline",
609    },
610    LanguageFixture {
611        language: "Markdown",
612        source: "# Title\n\n```rust\nfn main() {}\n```\n",
613        description: "Markdown document with embedded fenced code",
614    },
615    LanguageFixture {
616        language: "HTML",
617        source: "<script>const x = 1;</script><style>.x { color: red; }</style><p style=\"color: blue\">text</p>\n",
618        description: "HTML document with script, style, and style-attribute regions",
619    },
620    LanguageFixture {
621        language: "Python",
622        source: "def f(x):\n    return x + 1\n",
623        description: "Python function with indentation",
624    },
625    LanguageFixture {
626        language: "C",
627        source: "int main(void) { return 0; }\n",
628        description: "C entry point",
629    },
630    LanguageFixture {
631        language: "Java",
632        source: "class Main { public static void main(String[] args) {} }\n",
633        description: "Java class entry point",
634    },
635    LanguageFixture {
636        language: "C++",
637        source: "int main() { return 0; }\n",
638        description: "C++ entry point",
639    },
640    LanguageFixture {
641        language: "C#",
642        source: "class C { static void Main() {} }\n",
643        description: "C# class entry point",
644    },
645    LanguageFixture {
646        language: "JavaScript",
647        source: "const value = 1;\n",
648        description: "JavaScript binding",
649    },
650    LanguageFixture {
651        language: "Visual Basic",
652        source: "Module Program\nEnd Module\n",
653        description: "Visual Basic module",
654    },
655    LanguageFixture {
656        language: "R",
657        source: "value <- 1\n",
658        description: "R assignment",
659    },
660    LanguageFixture {
661        language: "SQL",
662        source: "SELECT 1;\n",
663        description: "SQL select statement",
664    },
665    LanguageFixture {
666        language: "Delphi/Object Pascal",
667        source: "program Demo;\nbegin\nend.\n",
668        description: "Delphi/Object Pascal program",
669    },
670    LanguageFixture {
671        language: "English",
672        source: "Hawaii is a state.\n",
673        description: "English formalization sentence",
674    },
675    LanguageFixture {
676        language: "Mandarin Chinese",
677        source: "你好。\n",
678        description: "Mandarin Chinese sentence",
679    },
680    LanguageFixture {
681        language: "Hindi",
682        source: "नमस्ते।\n",
683        description: "Hindi sentence",
684    },
685    LanguageFixture {
686        language: "Spanish",
687        source: "Hawaii es un estado.\n",
688        description: "Spanish reconstruction sentence",
689    },
690    LanguageFixture {
691        language: "French",
692        source: "Hawaii est un etat.\n",
693        description: "French reconstruction sentence",
694    },
695    LanguageFixture {
696        language: "Modern Standard Arabic",
697        source: "مرحبا.\n",
698        description: "Modern Standard Arabic sentence",
699    },
700    LanguageFixture {
701        language: "Bengali",
702        source: "নমস্কার।\n",
703        description: "Bengali sentence",
704    },
705    LanguageFixture {
706        language: "Russian",
707        source: "Гавайи это штат.\n",
708        description: "Russian reconstruction sentence",
709    },
710    LanguageFixture {
711        language: "Portuguese",
712        source: "Hawaii e um estado.\n",
713        description: "Portuguese reconstruction sentence",
714    },
715    LanguageFixture {
716        language: "Urdu",
717        source: "سلام۔\n",
718        description: "Urdu sentence",
719    },
720];
721
722/// Mixed-grammar embedding case that must become one unified links network.
723#[derive(Clone, Copy, Debug, PartialEq, Eq)]
724pub struct GrammarEmbeddingTarget {
725    host_language: &'static str,
726    embedded_language: &'static str,
727    trigger: &'static str,
728}
729
730impl GrammarEmbeddingTarget {
731    /// Host language containing the embedded region.
732    #[must_use]
733    pub const fn host_language(&self) -> &'static str {
734        self.host_language
735    }
736
737    /// Embedded region language or language family.
738    #[must_use]
739    pub const fn embedded_language(&self) -> &'static str {
740        self.embedded_language
741    }
742
743    /// Detection trigger or boundary.
744    #[must_use]
745    pub const fn trigger(&self) -> &'static str {
746        self.trigger
747    }
748}
749
750/// Initial mixed-grammar coverage targets.
751pub const GRAMMAR_EMBEDDING_TARGETS: &[GrammarEmbeddingTarget] = &[
752    GrammarEmbeddingTarget {
753        host_language: "Markdown",
754        embedded_language: "Programming language region",
755        trigger: "fenced code language tag",
756    },
757    GrammarEmbeddingTarget {
758        host_language: "Markdown",
759        embedded_language: "HTML",
760        trigger: "inline or block HTML",
761    },
762    GrammarEmbeddingTarget {
763        host_language: "HTML",
764        embedded_language: "JavaScript",
765        trigger: "script element",
766    },
767    GrammarEmbeddingTarget {
768        host_language: "HTML",
769        embedded_language: "CSS",
770        trigger: "style element or style attribute",
771    },
772];
meta_language/parity.rs

meta_language/
parity.rs
