@warpgogol/werkstatt-shared 0.14.1 → 0.15.0

package/src/typography/rules-tier2-structure.test.ts

@@ -0,0 +1,330 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for Tier 2 structure typography rules (RFC-1069). Tests each
+of the 9 rules (TYPO-HEAD-01..03, TYPO-PAIR-01..03, TYPO-MD-01..03) with
+positive and negative cases, including edge cases for frontmatter heading
+detection, link-stripping interactions, and placeholder exclusions.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1069: initial test suite for 9 Tier 2 structure rules.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { describe, it, expect } from "vitest";
+import {
+  TIER2_STRUCTURE_RULES,
+  createTypographyContext,
+  type TextSegment,
+  type TypographyFinding,
+} from "./index.ts";
+
+function makeSegment(text: string, overrides: Partial<TextSegment> = {}): TextSegment {
+  return {
+    file: "test.md",
+    line: 1,
+    path: "$body",
+    source: "body",
+    text,
+    raw: text,
+    isTableRow: false,
+    locale: "de",
+    ...overrides,
+  };
+}
+
+function makeFmSegment(
+  text: string,
+  path: string,
+  overrides: Partial<TextSegment> = {},
+): TextSegment {
+  return makeSegment(text, {
+    source: "frontmatter",
+    path,
+    ...overrides,
+  });
+}
+
+const ctx = createTypographyContext("de", new Set());
+
+function runRule(ruleId: string, segment: TextSegment): TypographyFinding[] {
+  const rule = TIER2_STRUCTURE_RULES.find((r) => r.id === ruleId);
+  if (!rule) throw new Error(`Rule ${ruleId} not found`);
+  return rule.check(segment, ctx);
+}
+
+// ---------------------------------------------------------------------------
+// TYPO-HEAD-01: Heading ends with a period
+// ---------------------------------------------------------------------------
+
+describe("TYPO-HEAD-01", () => {
+  it("flags a body heading ending with a period", () => {
+    const seg = makeSegment("## My Heading.");
+    const findings = runRule("TYPO-HEAD-01", seg);
+    expect(findings).toHaveLength(1);
+    expect(findings[0].ruleId).toBe("TYPO-HEAD-01");
+  });
+
+  it("does not flag a body heading without trailing period", () => {
+    const seg = makeSegment("## My Heading");
+    expect(runRule("TYPO-HEAD-01", seg)).toHaveLength(0);
+  });
+
+  it("flags a frontmatter heading ending with a period", () => {
+    const seg = makeFmSegment("My Heading.", "$.blocks[0].props.heading");
+    expect(runRule("TYPO-HEAD-01", seg)).toHaveLength(1);
+  });
+
+  it("flags a frontmatter subheading ending with a period", () => {
+    const seg = makeFmSegment("My Subheading.", "$.blocks[0].props.subheading");
+    expect(runRule("TYPO-HEAD-01", seg)).toHaveLength(1);
+  });
+
+  it("does not flag a frontmatter non-heading key ending with a period", () => {
+    const seg = makeFmSegment("Some text.", "$.blocks[0].props.title");
+    expect(runRule("TYPO-HEAD-01", seg)).toHaveLength(0);
+  });
+
+  it("does not flag a non-heading body line ending with a period", () => {
+    const seg = makeSegment("This is a sentence.");
+    expect(runRule("TYPO-HEAD-01", seg)).toHaveLength(0);
+  });
+
+  // RFC-1083: multi-line body fields starting with ## are NOT headings
+  it("does not flag a multi-line body field starting with ##", () => {
+    const seg = makeSegment("## Heading\nMore body content.");
+    expect(runRule("TYPO-HEAD-01", seg)).toHaveLength(0);
+  });
+
+  it("still flags a single-line heading ending with a period", () => {
+    const seg = makeSegment("## Heading.");
+    expect(runRule("TYPO-HEAD-01", seg)).toHaveLength(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-HEAD-02: Heading ends with a colon or dash
+// ---------------------------------------------------------------------------
+
+describe("TYPO-HEAD-02", () => {
+  it("flags a heading ending with a colon", () => {
+    const seg = makeSegment("## Heading:");
+    expect(runRule("TYPO-HEAD-02", seg)).toHaveLength(1);
+  });
+
+  it("flags a heading ending with an em-dash", () => {
+    const seg = makeSegment("## Heading\u2014");
+    expect(runRule("TYPO-HEAD-02", seg)).toHaveLength(1);
+  });
+
+  it("flags a heading ending with an en-dash", () => {
+    const seg = makeSegment("## Heading\u2013");
+    expect(runRule("TYPO-HEAD-02", seg)).toHaveLength(1);
+  });
+
+  it("flags a heading ending with a hyphen", () => {
+    const seg = makeSegment("## Heading-");
+    expect(runRule("TYPO-HEAD-02", seg)).toHaveLength(1);
+  });
+
+  it("does not flag a heading without trailing colon or dash", () => {
+    const seg = makeSegment("## Heading");
+    expect(runRule("TYPO-HEAD-02", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-HEAD-03: Heading ends with other closing punctuation
+// ---------------------------------------------------------------------------
+
+describe("TYPO-HEAD-03", () => {
+  it("flags a heading ending with !", () => {
+    const seg = makeSegment("## Heading!");
+    expect(runRule("TYPO-HEAD-03", seg)).toHaveLength(1);
+  });
+
+  it("flags a heading ending with ?", () => {
+    const seg = makeSegment("## Heading?");
+    expect(runRule("TYPO-HEAD-03", seg)).toHaveLength(1);
+  });
+
+  it("flags a heading ending with )", () => {
+    const seg = makeSegment("## Heading)");
+    expect(runRule("TYPO-HEAD-03", seg)).toHaveLength(1);
+  });
+
+  it("does not flag a heading without trailing closing punctuation", () => {
+    const seg = makeSegment("## Heading");
+    expect(runRule("TYPO-HEAD-03", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-PAIR-01: Unbalanced round parentheses
+// ---------------------------------------------------------------------------
+
+describe("TYPO-PAIR-01", () => {
+  it("flags 3 opening and 2 closing parentheses", () => {
+    const seg = makeSegment("Text (foo (bar) baz");
+    const findings = runRule("TYPO-PAIR-01", seg);
+    expect(findings).toHaveLength(1);
+    expect(findings[0].ruleId).toBe("TYPO-PAIR-01");
+  });
+
+  it("does not flag balanced parentheses", () => {
+    const seg = makeSegment("Text (foo) and (bar)");
+    expect(runRule("TYPO-PAIR-01", seg)).toHaveLength(0);
+  });
+
+  it("does not flag text with formula placeholder", () => {
+    const seg = makeSegment("Text \uE000 end");
+    expect(runRule("TYPO-PAIR-01", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-PAIR-02: Orphaned closing square bracket
+// ---------------------------------------------------------------------------
+
+describe("TYPO-PAIR-02", () => {
+  it("flags an orphaned ]", () => {
+    const seg = makeSegment("Text ] end");
+    expect(runRule("TYPO-PAIR-02", seg)).toHaveLength(1);
+  });
+
+  it("does not flag balanced [text]", () => {
+    const seg = makeSegment("Text [text] end");
+    expect(runRule("TYPO-PAIR-02", seg)).toHaveLength(0);
+  });
+
+  it("does not flag [text from a stripped link (orphaned [ is not a defect)", () => {
+    const seg = makeSegment("See [text for details");
+    expect(runRule("TYPO-PAIR-02", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-PAIR-03: Unbalanced curly braces
+// ---------------------------------------------------------------------------
+
+describe("TYPO-PAIR-03", () => {
+  it("flags unbalanced curly braces (more opening)", () => {
+    const seg = makeSegment("Text {foo {bar}");
+    expect(runRule("TYPO-PAIR-03", seg)).toHaveLength(1);
+  });
+
+  it("flags unbalanced curly braces (more closing)", () => {
+    const seg = makeSegment("Text {foo}}");
+    expect(runRule("TYPO-PAIR-03", seg)).toHaveLength(1);
+  });
+
+  it("does not flag balanced curly braces", () => {
+    const seg = makeSegment("Text {foo} and {bar}");
+    expect(runRule("TYPO-PAIR-03", seg)).toHaveLength(0);
+  });
+
+  it("does not flag CMS placeholder (braces already stripped)", () => {
+    const seg = makeSegment("Text \uE002 end");
+    expect(runRule("TYPO-PAIR-03", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-MD-01: Unclosed inline code span (odd backticks)
+// ---------------------------------------------------------------------------
+
+describe("TYPO-MD-01", () => {
+  it("flags an odd number of backticks", () => {
+    const seg = makeSegment("Text `code end");
+    expect(runRule("TYPO-MD-01", seg)).toHaveLength(1);
+  });
+
+  it("does not flag an even number of backticks", () => {
+    const seg = makeSegment("Text `code` end");
+    expect(runRule("TYPO-MD-01", seg)).toHaveLength(0);
+  });
+
+  it("does not flag frontmatter segments", () => {
+    const seg = makeFmSegment("Text `code", "$.blocks[0].props.text");
+    expect(runRule("TYPO-MD-01", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-MD-02: Broken link target syntax
+// ---------------------------------------------------------------------------
+
+describe("TYPO-MD-02", () => {
+  it("flags ]( without preceding [", () => {
+    const seg = makeSegment("Text ](url end");
+    expect(runRule("TYPO-MD-02", seg)).toHaveLength(1);
+  });
+
+  it("does not flag a complete link after stripping", () => {
+    // After link stripping, [text](url) becomes [text — no ]( remains
+    const seg = makeSegment("See [text for details");
+    expect(runRule("TYPO-MD-02", seg)).toHaveLength(0);
+  });
+
+  it("does not flag frontmatter segments", () => {
+    const seg = makeFmSegment("Text ](url", "$.blocks[0].props.text");
+    expect(runRule("TYPO-MD-02", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TYPO-MD-03: Unclosed emphasis marker
+// ---------------------------------------------------------------------------
+
+describe("TYPO-MD-03", () => {
+  it("flags an odd number of asterisks", () => {
+    const seg = makeSegment("Text *bold end");
+    expect(runRule("TYPO-MD-03", seg)).toHaveLength(1);
+  });
+
+  it("does not flag an even number of asterisks", () => {
+    const seg = makeSegment("Text **bold** end");
+    expect(runRule("TYPO-MD-03", seg)).toHaveLength(0);
+  });
+
+  it("flags an odd number of underscores", () => {
+    const seg = makeSegment("Text _italic end");
+    expect(runRule("TYPO-MD-03", seg)).toHaveLength(1);
+  });
+
+  it("does not flag an even number of underscores", () => {
+    const seg = makeSegment("Text _italic_ end");
+    expect(runRule("TYPO-MD-03", seg)).toHaveLength(0);
+  });
+
+  it("does not flag frontmatter segments", () => {
+    const seg = makeFmSegment("Text *bold", "$.blocks[0].props.text");
+    expect(runRule("TYPO-MD-03", seg)).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TIER2_STRUCTURE_RULES export
+// ---------------------------------------------------------------------------
+
+describe("TIER2_STRUCTURE_RULES", () => {
+  it("exports exactly 9 rules", () => {
+    expect(TIER2_STRUCTURE_RULES).toHaveLength(9);
+  });
+
+  it("all rules have tier 2", () => {
+    for (const rule of TIER2_STRUCTURE_RULES) {
+      expect(rule.tier).toBe(2);
+    }
+  });
+
+  it("all rules have severity error", () => {
+    for (const rule of TIER2_STRUCTURE_RULES) {
+      expect(rule.severity).toBe("error");
+    }
+  });
+
+  it("covers HEAD, PAIR, and MD families", () => {
+    const families = new Set(TIER2_STRUCTURE_RULES.map((r) => r.family));
+    expect(families).toEqual(new Set(["HEAD", "PAIR", "MD"]));
+  });
+});

package/src/typography/rules-tier2-structure.ts

@@ -0,0 +1,378 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Tier 2 structure typography rules (RFC-1069). Implements 9 rules across
+3 families: HEAD (3), PAIR (3), MD (3). Rules operate on TextSegment objects
+produced by the text-surface extractor (RFC-1068), never on raw file bytes.
+All regexes use the `u` flag and Unicode property escapes where applicable.</purpose>
+<non-goals>
+  <item>Do not extract text — that is text-surface.ts.</item>
+  <item>Do not handle file I/O or command registration — that is the command adapter.</item>
+  <item>Do not auto-fix — autofix is RFC-1072.</item>
+  <item>Do not validate heading hierarchy — that is a semantic concern, not typographic.</item>
+  <item>Do not validate list item punctuation — that is RFC-1067 (list.punctuation.validate).</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-1069: initial creation with 9 Tier 2 structure rules.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { TextSegment } from "./text-surface.ts";
+import { finding, type TypographyFinding, type TypographyRule } from "./rules-tier1.ts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type Tier2StructureRuleId = `TYPO-${"HEAD" | "PAIR" | "MD"}-${string}`;
+
+// ---------------------------------------------------------------------------
+// Helper: extract last path segment from a JSON-path
+// e.g. "$.blocks[0].props.heading" → "heading"
+// ---------------------------------------------------------------------------
+
+function lastPathKey(path: string): string | undefined {
+  const parts = path.split(".");
+  const last = parts[parts.length - 1];
+  if (!last || last.startsWith("$") || last.includes("[")) return undefined;
+  return last;
+}
+
+// ---------------------------------------------------------------------------
+// Helper: check if a segment is a heading (body or frontmatter)
+// ---------------------------------------------------------------------------
+
+function isBodyHeading(text: string): boolean {
+  // A body segment is a heading only if it is a single line starting with #
+  // (RFC-1083). Multi-line body fields starting with ## are NOT headings —
+  // they are body content. The `m` flag is unnecessary because
+  // !text.includes("\n") guarantees a single-line string.
+  return /^#{1,6}\s+.+$/u.test(text) && !text.includes("\n");
+}
+
+function isFrontmatterHeading(segment: TextSegment): boolean {
+  if (segment.source !== "frontmatter") return false;
+  const key = lastPathKey(segment.path);
+  return key === "heading" || key === "subheading";
+}
+
+// ---------------------------------------------------------------------------
+// TYPO-HEAD-01: Heading ends with a period
+// ---------------------------------------------------------------------------
+
+const HEAD01_PERIOD = /[.]\s*$/u;
+
+const head01: TypographyRule = {
+  id: "TYPO-HEAD-01",
+  family: "HEAD",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    const text = segment.text;
+    if (!isBodyHeading(text) && !isFrontmatterHeading(segment)) return [];
+    const match = HEAD01_PERIOD.exec(text);
+    if (!match) return [];
+    const col = match.index;
+    return [
+      finding(
+        "TYPO-HEAD-01",
+        segment,
+        match[0],
+        col,
+        "Heading ends with a period — a heading is a title, not a sentence.",
+        "Remove the trailing period.",
+      ),
+    ];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-HEAD-02: Heading ends with a colon or dash
+// ---------------------------------------------------------------------------
+
+const HEAD02_COLON_DASH = /[:\u2014\u2013-]\s*$/u;
+
+const head02: TypographyRule = {
+  id: "TYPO-HEAD-02",
+  family: "HEAD",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    const text = segment.text;
+    if (!isBodyHeading(text) && !isFrontmatterHeading(segment)) return [];
+    const match = HEAD02_COLON_DASH.exec(text);
+    if (!match) return [];
+    const col = match.index;
+    return [
+      finding(
+        "TYPO-HEAD-02",
+        segment,
+        match[0],
+        col,
+        "Heading ends with a colon or dash — trailing punctuation is always wrong in a heading.",
+        "Remove the trailing colon or dash.",
+      ),
+    ];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-HEAD-03: Heading ends with other closing punctuation (!?)])
+// ---------------------------------------------------------------------------
+
+const HEAD03_OTHER = /[)!?]\s*$/u;
+
+const head03: TypographyRule = {
+  id: "TYPO-HEAD-03",
+  family: "HEAD",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    const text = segment.text;
+    if (!isBodyHeading(text) && !isFrontmatterHeading(segment)) return [];
+    const match = HEAD03_OTHER.exec(text);
+    if (!match) return [];
+    const col = match.index;
+    return [
+      finding(
+        "TYPO-HEAD-03",
+        segment,
+        match[0],
+        col,
+        "Heading ends with closing punctuation (!, ?, or )) — a heading should not end with these marks.",
+        "Remove the trailing punctuation.",
+      ),
+    ];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-PAIR-01: Unbalanced round parentheses
+// Exclusions: code spans (already stripped), formulas (replaced with placeholder)
+// ---------------------------------------------------------------------------
+
+function countChar(text: string, ch: string): number {
+  let count = 0;
+  for (const c of text) {
+    if (c === ch) count++;
+  }
+  return count;
+}
+
+const pair01: TypographyRule = {
+  id: "TYPO-PAIR-01",
+  family: "PAIR",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    const text = segment.text;
+    const open = countChar(text, "(");
+    const close = countChar(text, ")");
+    if (open === close) return [];
+    const col = open > close ? text.lastIndexOf("(") : text.lastIndexOf(")");
+    return [
+      finding(
+        "TYPO-PAIR-01",
+        segment,
+        open > close ? "(" : ")",
+        col,
+        `Unbalanced round parentheses — ${open} opening, ${close} closing.`,
+        "Add or remove a parenthesis to balance the pair.",
+      ),
+    ];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-PAIR-02: Orphaned closing square bracket
+// After removing balanced [...] pairs, any ] remaining is an orphan.
+// Exclusions: markdown link syntax (the link-stripping step removes ](...) leaving
+// [text — orphaned [ is expected and not a defect); code spans
+// ---------------------------------------------------------------------------
+
+const pair02: TypographyRule = {
+  id: "TYPO-PAIR-02",
+  family: "PAIR",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    const text = segment.text;
+    // Find orphan ] by scanning the original string and skipping balanced [..] pairs.
+    let i = 0;
+    let bracketDepth = 0;
+    while (i < text.length) {
+      if (text[i] === "[") {
+        bracketDepth++;
+      } else if (text[i] === "]") {
+        if (bracketDepth === 0) {
+          return [
+            finding(
+              "TYPO-PAIR-02",
+              segment,
+              "]",
+              i,
+              "Orphaned closing square bracket — a ] without a matching [.",
+              "Add the opening [ or remove the orphaned ].",
+            ),
+          ];
+        }
+        bracketDepth--;
+      }
+      i++;
+    }
+    return [];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-PAIR-03: Unbalanced curly braces
+// Exclusions: formula expressions (replaced with placeholder), frontmatter
+// template variables (replaced with CMS placeholder by extractor)
+// ---------------------------------------------------------------------------
+
+const pair03: TypographyRule = {
+  id: "TYPO-PAIR-03",
+  family: "PAIR",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    const text = segment.text;
+    const open = countChar(text, "{");
+    const close = countChar(text, "}");
+    if (open === close) return [];
+    const col = open > close ? text.lastIndexOf("{") : text.lastIndexOf("}");
+    return [
+      finding(
+        "TYPO-PAIR-03",
+        segment,
+        open > close ? "{" : "}",
+        col,
+        `Unbalanced curly braces — ${open} opening, ${close} closing.`,
+        "Add or remove a brace to balance the pair.",
+      ),
+    ];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-MD-01: Unclosed inline code span (odd number of backticks)
+// Exclusions: fenced code blocks (removed by extractor)
+// ---------------------------------------------------------------------------
+
+const md01: TypographyRule = {
+  id: "TYPO-MD-01",
+  family: "MD",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    if (segment.source !== "body") return [];
+    const text = segment.text;
+    const backtickCount = countChar(text, "`");
+    if (backtickCount % 2 === 0) return [];
+    const col = text.lastIndexOf("`");
+    return [
+      finding(
+        "TYPO-MD-01",
+        segment,
+        "`",
+        col,
+        `Unclosed inline code span — odd number of backticks (${backtickCount}).`,
+        "Add a closing backtick to match the opening.",
+      ),
+    ];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-MD-02: Broken link target syntax (](… without preceding [)
+// Only checks ]( without a preceding ] on the same segment.
+// Unclosed [text at end of segment is NOT checked because the link-stripping
+// step removes ](...) making [text indistinguishable from a complete link.
+// ---------------------------------------------------------------------------
+
+const MD02_PATTERN = /(?<!\])\]\(/u;
+
+const md02: TypographyRule = {
+  id: "TYPO-MD-02",
+  family: "MD",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    if (segment.source !== "body") return [];
+    const text = segment.text;
+    const match = MD02_PATTERN.exec(text);
+    if (!match) return [];
+    return [
+      finding(
+        "TYPO-MD-02",
+        segment,
+        match[0],
+        match.index,
+        "Broken link target syntax — ]( without a matching [.",
+        "Add the opening [ or remove the orphaned ](.",
+      ),
+    ];
+  },
+};
+
+// ---------------------------------------------------------------------------
+// TYPO-MD-03: Unclosed emphasis marker (odd count of * or _)
+// Exclusions: code spans (already stripped); formulas (replaced with placeholder)
+// ---------------------------------------------------------------------------
+
+const md03: TypographyRule = {
+  id: "TYPO-MD-03",
+  family: "MD",
+  tier: 2,
+  severity: "error",
+  check(segment) {
+    if (segment.source !== "body") return [];
+    const text = segment.text;
+    const starCount = countChar(text, "*");
+    const underscoreCount = countChar(text, "_");
+    const findings: TypographyFinding[] = [];
+    if (starCount % 2 !== 0) {
+      const col = text.lastIndexOf("*");
+      findings.push(
+        finding(
+          "TYPO-MD-03",
+          segment,
+          "*",
+          col,
+          `Unclosed emphasis marker — odd number of asterisks (${starCount}).`,
+          "Add a closing * to match the opening.",
+        ),
+      );
+    }
+    if (underscoreCount % 2 !== 0) {
+      const col = text.lastIndexOf("_");
+      findings.push(
+        finding(
+          "TYPO-MD-03",
+          segment,
+          "_",
+          col,
+          `Unclosed emphasis marker — odd number of underscores (${underscoreCount}).`,
+          "Add a closing _ to match the opening.",
+        ),
+      );
+    }
+    return findings;
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Export all Tier 2 structure rules
+// ---------------------------------------------------------------------------
+
+export const TIER2_STRUCTURE_RULES: readonly TypographyRule[] = [
+  head01,
+  head02,
+  head03,
+  pair01,
+  pair02,
+  pair03,
+  md01,
+  md02,
+  md03,
+];