diff --git a/Sources/Exercises/Participants/RegexParticipant.swift b/Sources/Exercises/Participants/RegexParticipant.swift
index e506d48e1..bae3aed42 100644
--- a/Sources/Exercises/Participants/RegexParticipant.swift
+++ b/Sources/Exercises/Participants/RegexParticipant.swift
@@ -61,8 +61,8 @@ private func extractFromCaptures(
 private func graphemeBreakPropertyData<RP: RegexComponent>(
   forLine line: String,
   using regex: RP
-) -> GraphemeBreakEntry? where RP.Match == (Substring, Substring, Substring?, Substring) {
-  line.match(regex).map(\.match).flatMap(extractFromCaptures)
+) -> GraphemeBreakEntry? where RP.Output == (Substring, Substring, Substring?, Substring) {
+  line.match(regex).map(\.output).flatMap(extractFromCaptures)
 }
 
 private func graphemeBreakPropertyDataLiteral(
@@ -91,7 +91,7 @@ private func graphemeBreakPropertyData(
     TryCapture(OneOrMore(.word)) { Unicode.GraphemeBreakProperty($0) }
     ZeroOrMore(.any)
   }.map {
-    let (_, lower, upper, property) = $0.match
+    let (_, lower, upper, property) = $0.output
     return GraphemeBreakEntry(lower...(upper ?? lower), property)
   }
 }
diff --git a/Sources/VariadicsGenerator/VariadicsGenerator.swift b/Sources/VariadicsGenerator/VariadicsGenerator.swift
index f98775267..683d45e6e 100644
--- a/Sources/VariadicsGenerator/VariadicsGenerator.swift
+++ b/Sources/VariadicsGenerator/VariadicsGenerator.swift
@@ -90,7 +90,7 @@ var standardError = StandardErrorStream()
 
 typealias Counter = Int64
 let regexComponentProtocolName = "RegexComponent"
-let matchAssociatedTypeName = "Match"
+let outputAssociatedTypeName = "Output"
 let patternProtocolRequirementName = "regex"
 let regexTypeName = "Regex"
 let baseMatchTypeName = "Substring"
@@ -202,7 +202,7 @@ struct VariadicsGenerator: ParsableCommand {
     // Emit concatenation type declaration.
 
     let whereClause: String = {
-      var result = " where R0.Match == "
+      var result = " where R0.\(outputAssociatedTypeName) == "
       if leftArity == 0 {
         result += "W0"
       } else {
@@ -210,7 +210,7 @@ struct VariadicsGenerator: ParsableCommand {
         result += (0..<leftArity).map { ", C\($0)" }.joined()
         result += ")"
       }
-      result += ", R1.Match == "
+      result += ", R1.\(outputAssociatedTypeName) == "
       if rightArity == 0 {
         result += "W1"
       } else {
@@ -267,7 +267,7 @@ struct VariadicsGenerator: ParsableCommand {
       }
       output(")")
     }
-    output("> where R0.\(matchAssociatedTypeName) == ")
+    output("> where R0.\(outputAssociatedTypeName) == ")
     if leftArity == 0 {
       output("W0")
     } else {
@@ -348,10 +348,10 @@ struct VariadicsGenerator: ParsableCommand {
       self.matchType = arity == 0
         ? baseMatchTypeName
         : "(\(baseMatchTypeName), \(quantifiedCaptures))"
-      self.whereClauseForInit = "where \(matchAssociatedTypeName) == \(matchType)" +
-        (arity == 0 ? "" : ", Component.Match == (W, \(capturesJoined))")
+      self.whereClauseForInit = "where \(outputAssociatedTypeName) == \(matchType)" +
+        (arity == 0 ? "" : ", Component.\(outputAssociatedTypeName) == (W, \(capturesJoined))")
       self.whereClause = arity == 0 ? "" :
-        "where Component.Match == (W, \(capturesJoined))"
+        "where Component.\(outputAssociatedTypeName) == (W, \(capturesJoined))"
     }
   }
 
@@ -468,10 +468,10 @@ struct VariadicsGenerator: ParsableCommand {
     let whereClause: String = {
       var result = "where R0: \(regexComponentProtocolName), R1: \(regexComponentProtocolName)"
       if leftArity > 0 {
-        result += ", R0.\(matchAssociatedTypeName) == (W0, \((0..<leftArity).map { "C\($0)" }.joined(separator: ", ")))"
+        result += ", R0.\(outputAssociatedTypeName) == (W0, \((0..<leftArity).map { "C\($0)" }.joined(separator: ", ")))"
       }
       if rightArity > 0 {
-        result += ", R1.\(matchAssociatedTypeName) == (W1, \((leftArity..<leftArity+rightArity).map { "C\($0)" }.joined(separator: ", ")))"
+        result += ", R1.\(outputAssociatedTypeName) == (W1, \((leftArity..<leftArity+rightArity).map { "C\($0)" }.joined(separator: ", ")))"
       }
       return result
     }()
@@ -516,7 +516,7 @@ struct VariadicsGenerator: ParsableCommand {
     }()
     let whereClause: String = """
       where R: \(regexComponentProtocolName), \
-      R.\(matchAssociatedTypeName) == (W, \(captures))
+      R.\(outputAssociatedTypeName) == (W, \(captures))
       """
     let resultCaptures = (0..<arity).map { "C\($0)?" }.joined(separator: ", ")
     output("""
@@ -544,8 +544,8 @@ struct VariadicsGenerator: ParsableCommand {
     }
     let rawNewMatchType = newMatchType(newCaptureType: "W")
     let transformedNewMatchType = newMatchType(newCaptureType: "NewCapture")
-    let whereClauseRaw = "where \(matchAssociatedTypeName) == \(rawNewMatchType), R.\(matchAssociatedTypeName) == \(matchType)"
-    let whereClauseTransformed = "where \(matchAssociatedTypeName) == \(transformedNewMatchType), R.\(matchAssociatedTypeName) == \(matchType)"
+    let whereClauseRaw = "where \(outputAssociatedTypeName) == \(rawNewMatchType), R.\(outputAssociatedTypeName) == \(matchType)"
+    let whereClauseTransformed = "where \(outputAssociatedTypeName) == \(transformedNewMatchType), R.\(outputAssociatedTypeName) == \(matchType)"
     output("""
       // MARK: - Non-builder capture arity \(arity)
 
diff --git a/Sources/_StringProcessing/Algorithms/Consumers/RegexConsumer.swift b/Sources/_StringProcessing/Algorithms/Consumers/RegexConsumer.swift
index 331246d0e..4dac3cef5 100644
--- a/Sources/_StringProcessing/Algorithms/Consumers/RegexConsumer.swift
+++ b/Sources/_StringProcessing/Algorithms/Consumers/RegexConsumer.swift
@@ -28,7 +28,7 @@ extension RegexConsumer {
       consumed.base,
       in: range, mode: .partialFromFront
     ) else { return nil }
-    return (result.range.upperBound, result.match)
+    return (result.range.upperBound, result.output)
   }
 }
 
@@ -36,7 +36,7 @@ extension RegexConsumer {
 // well, taking advantage of the fact that the captures can be ignored
 
 extension RegexConsumer: MatchingCollectionConsumer {
-  public typealias Match = R.Match
+  public typealias Match = R.Output
   
   public func matchingConsuming(
     _ consumed: Consumed, in range: Range<Consumed.Index>
diff --git a/Sources/_StringProcessing/Executor.swift b/Sources/_StringProcessing/Executor.swift
index 9e1a2a1a2..59e1782a7 100644
--- a/Sources/_StringProcessing/Executor.swift
+++ b/Sources/_StringProcessing/Executor.swift
@@ -19,11 +19,11 @@ struct Executor {
     self.engine = Engine(program, enableTracing: enablesTracing)
   }
 
-  func match<Match>(
+  func match<Output>(
     _ input: String,
     in inputRange: Range<String.Index>,
     _ mode: MatchMode
-  ) throws -> MatchResult<Match>? {
+  ) throws -> Regex<Output>.Match? {
     var cpu = engine.makeProcessor(
       input: input, bounds: inputRange, matchMode: mode)
 
@@ -43,8 +43,8 @@ struct Executor {
     // FIXME: This is a workaround for not tracking (or
     // specially compiling) whole-match values.
     let value: Any?
-    if Match.self != Substring.self,
-       Match.self != (Substring, DynamicCaptures).self,
+    if Output.self != Substring.self,
+       Output.self != (Substring, DynamicCaptures).self,
        caps.isEmpty
     {
       value = cpu.registers.values.first
@@ -53,7 +53,7 @@ struct Executor {
       value = nil
     }
 
-    return MatchResult(
+    return .init(
       input: input,
       range: range,
       rawCaptures: caps,
@@ -65,7 +65,7 @@ struct Executor {
     _ input: String,
     in inputRange: Range<String.Index>,
     _ mode: MatchMode
-  ) throws -> MatchResult<(Substring, DynamicCaptures)>? {
+  ) throws -> Regex<(Substring, DynamicCaptures)>.Match? {
     try match(input, in: inputRange, mode)
   }
 }
diff --git a/Sources/_StringProcessing/RegexDSL/Anchor.swift b/Sources/_StringProcessing/RegexDSL/Anchor.swift
index f8c8e759f..57d8f2ffa 100644
--- a/Sources/_StringProcessing/RegexDSL/Anchor.swift
+++ b/Sources/_StringProcessing/RegexDSL/Anchor.swift
@@ -109,13 +109,13 @@ extension Anchor {
 public func lookahead<R: RegexComponent>(
   negative: Bool = false,
   @RegexComponentBuilder _ content: () -> R
-) -> Regex<R.Match> {
+) -> Regex<R.Output> {
   Regex(node: .nonCapturingGroup(negative ? .negativeLookahead : .lookahead, content().regex.root))
 }
   
 public func lookahead<R: RegexComponent>(
   _ component: R,
   negative: Bool = false
-) -> Regex<R.Match> {
+) -> Regex<R.Output> {
   Regex(node: .nonCapturingGroup(negative ? .negativeLookahead : .lookahead, component.regex.root))
 }
diff --git a/Sources/_StringProcessing/RegexDSL/Core.swift b/Sources/_StringProcessing/RegexDSL/Core.swift
index 461719c52..236888c77 100644
--- a/Sources/_StringProcessing/RegexDSL/Core.swift
+++ b/Sources/_StringProcessing/RegexDSL/Core.swift
@@ -14,12 +14,12 @@ import _MatchingEngine
 
 /// A type that represents a regular expression.
 public protocol RegexComponent {
-  associatedtype Match
-  var regex: Regex<Match> { get }
+  associatedtype Output
+  var regex: Regex<Output> { get }
 }
 
 /// A regular expression.
-public struct Regex<Match>: RegexComponent {
+public struct Regex<Output>: RegexComponent {
   /// A program representation that caches any lowered representation for
   /// execution.
   internal class Program {
@@ -80,37 +80,37 @@ public struct Regex<Match>: RegexComponent {
 
   public init<Content: RegexComponent>(
     _ content: Content
-  ) where Content.Match == Match {
+  ) where Content.Output == Output {
     self = content.regex
   }
 
   public init<Content: RegexComponent>(
     @RegexComponentBuilder _ content: () -> Content
-  ) where Content.Match == Match {
+  ) where Content.Output == Output {
     self.init(content())
   }
 
-  public var regex: Regex<Match> {
+  public var regex: Regex<Output> {
     self
   }
 }
 
 
-public struct MockRegexLiteral<Match>: RegexComponent {
+public struct MockRegexLiteral<Output>: RegexComponent {
   public typealias MatchValue = Substring
-  public let regex: Regex<Match>
+  public let regex: Regex<Output>
 
   public init(
     _ string: String,
     _ syntax: SyntaxOptions = .traditional,
-    matching: Match.Type = Match.self
+    matching: Output.Type = Output.self
   ) throws {
     regex = Regex(ast: try parse(string, syntax))
   }
 }
 
-public func r<Match>(
-  _ s: String, matching matchType: Match.Type = Match.self
-) -> MockRegexLiteral<Match> {
+public func r<Output>(
+  _ s: String, matching matchType: Output.Type = Output.self
+) -> MockRegexLiteral<Output> {
   try! MockRegexLiteral(s, matching: matchType)
 }
diff --git a/Sources/_StringProcessing/RegexDSL/DSL.swift b/Sources/_StringProcessing/RegexDSL/DSL.swift
index f10a95c38..4c3c382cc 100644
--- a/Sources/_StringProcessing/RegexDSL/DSL.swift
+++ b/Sources/_StringProcessing/RegexDSL/DSL.swift
@@ -14,7 +14,7 @@ import _MatchingEngine
 // A convenience protocol for builtin regex components that are initialized with
 // a `DSLTree` node.
 internal protocol _BuiltinRegexComponent: RegexComponent {
-  init(_ regex: Regex<Match>)
+  init(_ regex: Regex<Output>)
 }
 
 extension _BuiltinRegexComponent {
@@ -26,41 +26,41 @@ extension _BuiltinRegexComponent {
 // MARK: - Primitives
 
 extension String: RegexComponent {
-  public typealias Match = Substring
+  public typealias Output = Substring
 
-  public var regex: Regex<Match> {
+  public var regex: Regex<Output> {
     .init(node: .quotedLiteral(self))
   }
 }
 
 extension Substring: RegexComponent {
-  public typealias Match = Substring
+  public typealias Output = Substring
 
-  public var regex: Regex<Match> {
+  public var regex: Regex<Output> {
     .init(node: .quotedLiteral(String(self)))
   }
 }
 
 extension Character: RegexComponent {
-  public typealias Match = Substring
+  public typealias Output = Substring
 
-  public var regex: Regex<Match> {
+  public var regex: Regex<Output> {
     .init(node: .atom(.char(self)))
   }
 }
 
 extension UnicodeScalar: RegexComponent {
-  public typealias Match = Substring
+  public typealias Output = Substring
 
-  public var regex: Regex<Match> {
+  public var regex: Regex<Output> {
     .init(node: .atom(.scalar(self)))
   }
 }
 
 extension CharacterClass: RegexComponent {
-  public typealias Match = Substring
+  public typealias Output = Substring
 
-  public var regex: Regex<Match> {
+  public var regex: Regex<Output> {
     guard let ast = self.makeAST() else {
       fatalError("FIXME: extended AST?")
     }
@@ -79,7 +79,7 @@ extension CharacterClass: RegexComponent {
 // where R0.Match == (W0, C0...), R1.Match == (W1, C1...)
 // {
 //   typealias Match = (Substring, C0..., C1...)
-//   let regex: Regex<Match>
+//   let regex: Regex<Output>
 //   init(_ first: R0, _ second: R1) {
 //     regex = .init(concat(r0, r1))
 //   }
@@ -127,10 +127,10 @@ extension QuantificationBehavior {
   }
 }
 
-public struct OneOrMore<Match>: _BuiltinRegexComponent {
-  public var regex: Regex<Match>
+public struct OneOrMore<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
 
-  internal init(_ regex: Regex<Match>) {
+  internal init(_ regex: Regex<Output>) {
     self.regex = regex
   }
 
@@ -138,10 +138,10 @@ public struct OneOrMore<Match>: _BuiltinRegexComponent {
   // Variadics.swift.
 }
 
-public struct ZeroOrMore<Match>: _BuiltinRegexComponent {
-  public var regex: Regex<Match>
+public struct ZeroOrMore<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
 
-  internal init(_ regex: Regex<Match>) {
+  internal init(_ regex: Regex<Output>) {
     self.regex = regex
   }
 
@@ -149,10 +149,10 @@ public struct ZeroOrMore<Match>: _BuiltinRegexComponent {
   // Variadics.swift.
 }
 
-public struct Optionally<Match>: _BuiltinRegexComponent {
-  public var regex: Regex<Match>
+public struct Optionally<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
 
-  internal init(_ regex: Regex<Match>) {
+  internal init(_ regex: Regex<Output>) {
     self.regex = regex
   }
 
@@ -160,10 +160,10 @@ public struct Optionally<Match>: _BuiltinRegexComponent {
   // Variadics.swift.
 }
 
-public struct Repeat<Match>: _BuiltinRegexComponent {
-  public var regex: Regex<Match>
+public struct Repeat<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
 
-  internal init(_ regex: Regex<Match>) {
+  internal init(_ regex: Regex<Output>) {
     self.regex = regex
   }
 
@@ -194,7 +194,7 @@ public struct AlternationBuilder {
   @_disfavoredOverload
   public static func buildPartialBlock<R: RegexComponent>(
     first component: R
-  ) -> ChoiceOf<R.Match> {
+  ) -> ChoiceOf<R.Output> {
     .init(component.regex)
   }
 
@@ -211,10 +211,10 @@ public struct AlternationBuilder {
   }
 }
 
-public struct ChoiceOf<Match>: _BuiltinRegexComponent {
-  public var regex: Regex<Match>
+public struct ChoiceOf<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
 
-  internal init(_ regex: Regex<Match>) {
+  internal init(_ regex: Regex<Output>) {
     self.regex = regex
   }
 
@@ -225,20 +225,20 @@ public struct ChoiceOf<Match>: _BuiltinRegexComponent {
 
 // MARK: - Capture
 
-public struct Capture<Match>: _BuiltinRegexComponent {
-  public var regex: Regex<Match>
+public struct Capture<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
 
-  internal init(_ regex: Regex<Match>) {
+  internal init(_ regex: Regex<Output>) {
     self.regex = regex
   }
 
   // Note: Public initializers are currently gyb'd. See Variadics.swift.
 }
 
-public struct TryCapture<Match>: _BuiltinRegexComponent {
-  public var regex: Regex<Match>
+public struct TryCapture<Output>: _BuiltinRegexComponent {
+  public var regex: Regex<Output>
 
-  internal init(_ regex: Regex<Match>) {
+  internal init(_ regex: Regex<Output>) {
     self.regex = regex
   }
 
diff --git a/Sources/_StringProcessing/RegexDSL/DSLConsumers.swift b/Sources/_StringProcessing/RegexDSL/DSLConsumers.swift
index 6b2520973..8d64f8355 100644
--- a/Sources/_StringProcessing/RegexDSL/DSLConsumers.swift
+++ b/Sources/_StringProcessing/RegexDSL/DSLConsumers.swift
@@ -14,12 +14,12 @@ public protocol CustomRegexComponent: RegexComponent {
     _ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
-  ) -> (upperBound: String.Index, match: Match)?
+  ) -> (upperBound: String.Index, output: Output)?
 }
 
 extension CustomRegexComponent {
-  public var regex: Regex<Match> {
-    Regex(node: .matcher(.init(Match.self), { input, index, bounds in
+  public var regex: Regex<Output> {
+    Regex(node: .matcher(.init(Output.self), { input, index, bounds in
       match(input, startingAt: index, in: bounds)
     }))
   }
diff --git a/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift b/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift
index 24c182564..b5399ff86 100644
--- a/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift
+++ b/Sources/_StringProcessing/RegexDSL/DynamicCaptures.swift
@@ -11,7 +11,7 @@
 
 import _MatchingEngine
 
-extension Regex where Match == (Substring, DynamicCaptures) {
+extension Regex where Output == (Substring, DynamicCaptures) {
   public init(_ pattern: String) throws {
     self.init(ast: try parse(pattern, .traditional))
   }
diff --git a/Sources/_StringProcessing/RegexDSL/Match.swift b/Sources/_StringProcessing/RegexDSL/Match.swift
index 53199f9bb..1e5c67f98 100644
--- a/Sources/_StringProcessing/RegexDSL/Match.swift
+++ b/Sources/_StringProcessing/RegexDSL/Match.swift
@@ -9,48 +9,52 @@
 //
 //===----------------------------------------------------------------------===//
 
-@dynamicMemberLookup
-public struct MatchResult<Match> {
-  let input: String
-  public let range: Range<String.Index>
-  let rawCaptures: [StructuredCapture]
-  let referencedCaptureOffsets: [ReferenceID: Int]
+extension Regex {
+  @dynamicMemberLookup
+  public struct Match {
+    let input: String
+    public let range: Range<String.Index>
+    let rawCaptures: [StructuredCapture]
+    let referencedCaptureOffsets: [ReferenceID: Int]
 
-  let value: Any?
+    let value: Any?
+  }
+}
 
-  public var match: Match {
-    if Match.self == (Substring, DynamicCaptures).self {
+extension Regex.Match {
+  public var output: Output {
+    if Output.self == (Substring, DynamicCaptures).self {
       // FIXME(rdar://89449323): Compiler assertion
       let input = input
       let dynCaps = rawCaptures.map { StoredDynamicCapture($0, in: input) }
-      return (input[range], dynCaps) as! Match
-    } else if Match.self == Substring.self {
+      return (input[range], dynCaps) as! Output
+    } else if Output.self == Substring.self {
       // FIXME: Plumb whole match (`.0`) through the matching engine.
-      return input[range] as! Match
+      return input[range] as! Output
     } else if rawCaptures.isEmpty, value != nil {
       // FIXME: This is a workaround for whole-match values not
       // being modeled as part of captures. We might want to
       // switch to a model where results are alongside captures
-      return value! as! Match
+      return value! as! Output
     } else {
       guard value == nil else {
         fatalError("FIXME: what would this mean?")
       }
       let typeErasedMatch = rawCaptures.existentialMatch(from: input[range])
-      return typeErasedMatch as! Match
+      return typeErasedMatch as! Output
     }
   }
 
-  public subscript<T>(dynamicMember keyPath: KeyPath<Match, T>) -> T {
-    match[keyPath: keyPath]
+  public subscript<T>(dynamicMember keyPath: KeyPath<Output, T>) -> T {
+    output[keyPath: keyPath]
   }
 
   // Allows `.0` when `Match` is not a tuple.
   @_disfavoredOverload
   public subscript(
-    dynamicMember keyPath: KeyPath<(Match, _doNotUse: ()), Match>
-  ) -> Match {
-    match
+    dynamicMember keyPath: KeyPath<(Output, _doNotUse: ()), Output>
+  ) -> Output {
+    output
   }
 
   public subscript<Capture>(_ reference: Reference<Capture>) -> Capture {
@@ -64,11 +68,11 @@ public struct MatchResult<Match> {
 }
 
 extension RegexComponent {
-  public func match(in input: String) -> MatchResult<Match>? {
+  public func match(in input: String) -> Regex<Output>.Match? {
     _match(
       input, in: input.startIndex..<input.endIndex)
   }
-  public func match(in input: Substring) -> MatchResult<Match>? {
+  public func match(in input: Substring) -> Regex<Output>.Match? {
     _match(
       input.base, in: input.startIndex..<input.endIndex)
   }
@@ -77,7 +81,7 @@ extension RegexComponent {
     _ input: String,
     in inputRange: Range<String.Index>,
     mode: MatchMode = .wholeString
-  ) -> MatchResult<Match>? {
+  ) -> Regex<Output>.Match? {
     let executor = Executor(program: regex.program.loweredProgram)
     do {
       return try executor.match(input, in: inputRange, mode)
@@ -88,24 +92,24 @@ extension RegexComponent {
 }
 
 extension String {
-  public func match<R: RegexComponent>(_ regex: R) -> MatchResult<R.Match>? {
+  public func match<R: RegexComponent>(_ regex: R) -> Regex<R.Output>.Match? {
     regex.match(in: self)
   }
 
   public func match<R: RegexComponent>(
     @RegexComponentBuilder _ content: () -> R
-  ) -> MatchResult<R.Match>? {
+  ) -> Regex<R.Output>.Match? {
     match(content())
   }
 }
 extension Substring {
-  public func match<R: RegexComponent>(_ regex: R) -> MatchResult<R.Match>? {
+  public func match<R: RegexComponent>(_ regex: R) -> Regex<R.Output>.Match? {
     regex.match(in: self)
   }
 
   public func match<R: RegexComponent>(
     @RegexComponentBuilder _ content: () -> R
-  ) -> MatchResult<R.Match>? {
+  ) -> Regex<R.Output>.Match? {
     match(content())
   }
 }
diff --git a/Sources/_StringProcessing/RegexDSL/Options.swift b/Sources/_StringProcessing/RegexDSL/Options.swift
index ca20bc8f7..7876ae35c 100644
--- a/Sources/_StringProcessing/RegexDSL/Options.swift
+++ b/Sources/_StringProcessing/RegexDSL/Options.swift
@@ -12,7 +12,7 @@
 import _MatchingEngine
 
 extension RegexComponent {
-  public func caseSensitive(_ isCaseSensitive: Bool) -> Regex<Match> {
+  public func caseSensitive(_ isCaseSensitive: Bool) -> Regex<Output> {
     // The API is "case sensitive = true or false", so as to avoid the
     // double negatives inherent in setting "case insensitive" to a Boolean
     // value. The internal version of this option, on the other hand, is
diff --git a/Sources/_StringProcessing/RegexDSL/Variadics.swift b/Sources/_StringProcessing/RegexDSL/Variadics.swift
index 7a628d937..c81f8b555 100644
--- a/Sources/_StringProcessing/RegexDSL/Variadics.swift
+++ b/Sources/_StringProcessing/RegexDSL/Variadics.swift
@@ -16,462 +16,462 @@ import _MatchingEngine
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0)>  where R0.Match == W0, R1.Match == (W1, C0) {
+  ) -> Regex<(Substring, C0)>  where R0.Output == W0, R1.Output == (W1, C0) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1)>  where R0.Match == W0, R1.Match == (W1, C0, C1) {
+  ) -> Regex<(Substring, C0, C1)>  where R0.Output == W0, R1.Output == (W1, C0, C1) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2) {
+  ) -> Regex<(Substring, C0, C1, C2)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3) {
+  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2, C3) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2, C3, C4) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2, C3, C4, C5) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == W0, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == W0, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1)>  where R0.Match == (W0, C0), R1.Match == (W1, C1) {
+  ) -> Regex<(Substring, C0, C1)>  where R0.Output == (W0, C0), R1.Output == (W1, C1) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2) {
+  ) -> Regex<(Substring, C0, C1, C2)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3) {
+  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2) {
+  ) -> Regex<(Substring, C0, C1, C2)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3) {
+  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3) {
+  ) -> Regex<(Substring, C0, C1, C2, C3)>  where R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4)>  where R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)>  where R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Output == (W1, C8) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Output == (W1, C8, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8), R1.Match == (W1, C9) {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)>  where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8), R1.Output == (W1, C9) {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<Substring> where R0.Match == W0  {
+  ) -> Regex<Substring> where R0.Output == W0  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0)> where R0.Match == (W0, C0)  {
+  ) -> Regex<(Substring, C0)> where R0.Output == (W0, C0)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1)> where R0.Match == (W0, C0, C1)  {
+  ) -> Regex<(Substring, C0, C1)> where R0.Output == (W0, C0, C1)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2)> where R0.Match == (W0, C0, C1, C2)  {
+  ) -> Regex<(Substring, C0, C1, C2)> where R0.Output == (W0, C0, C1, C2)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, C3, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3)> where R0.Match == (W0, C0, C1, C2, C3)  {
+  ) -> Regex<(Substring, C0, C1, C2, C3)> where R0.Output == (W0, C0, C1, C2, C3)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, C3, C4, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4)> where R0.Match == (W0, C0, C1, C2, C3, C4)  {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4)> where R0.Output == (W0, C0, C1, C2, C3, C4)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, C3, C4, C5, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5)  {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5)> where R0.Output == (W0, C0, C1, C2, C3, C4, C5)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, C3, C4, C5, C6, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6)  {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6)> where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, C3, C4, C5, C6, C7, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7)  {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8)  {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
 extension RegexComponentBuilder {
   public static func buildPartialBlock<W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, R0: RegexComponent, R1: RegexComponent>(
     accumulated: R0, next: R1
-  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)> where R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)  {
+  ) -> Regex<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)> where R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)  {
     .init(node: accumulated.regex.root.appending(next.regex.root))
   }
 }
@@ -482,7 +482,7 @@ extension Optionally {
   public init<Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == Substring {
+  ) where Output == Substring {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -492,7 +492,7 @@ extension Optionally {
   public init<Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == Substring {
+  ) where Output == Substring {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
@@ -516,7 +516,7 @@ extension ZeroOrMore {
   public init<Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == Substring {
+  ) where Output == Substring {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -526,7 +526,7 @@ extension ZeroOrMore {
   public init<Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == Substring {
+  ) where Output == Substring {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
@@ -544,7 +544,7 @@ extension OneOrMore {
   public init<Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == Substring {
+  ) where Output == Substring {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -554,7 +554,7 @@ extension OneOrMore {
   public init<Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == Substring {
+  ) where Output == Substring {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
@@ -572,7 +572,7 @@ extension Repeat {
   public init<Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == Substring {
+  ) where Output == Substring {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -582,7 +582,7 @@ extension Repeat {
   public init<Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == Substring {
+  ) where Output == Substring {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -593,7 +593,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == Substring, R.Bound == Int {
+  ) where Output == Substring, R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -602,7 +602,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == Substring, R.Bound == Int {
+  ) where Output == Substring, R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -610,7 +610,7 @@ extension Optionally {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -619,21 +619,21 @@ extension Optionally {
     public init<W, C0, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?)> where Component.Match == (W, C0) {
+) -> Optionally<(Substring, C0?)> where Component.Output == (W, C0) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?)> where Component.Match == (W, C0) {
+  ) -> Regex<(Substring, C0?)> where Component.Output == (W, C0) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -641,7 +641,7 @@ extension ZeroOrMore {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -650,14 +650,14 @@ extension ZeroOrMore {
     public init<W, C0, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?)> where Component.Match == (W, C0) {
+) -> ZeroOrMore<(Substring, C0?)> where Component.Output == (W, C0) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -666,7 +666,7 @@ extension OneOrMore {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0), Component.Output == (W, C0) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -675,14 +675,14 @@ extension OneOrMore {
     public init<W, C0, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0), Component.Output == (W, C0) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0)> where Component.Match == (W, C0) {
+) -> OneOrMore<(Substring, C0)> where Component.Output == (W, C0) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -691,7 +691,7 @@ extension Repeat {
     public init<W, C0, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -700,7 +700,7 @@ extension Repeat {
     public init<W, C0, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?), Component.Match == (W, C0) {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -710,7 +710,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?), Component.Match == (W, C0), R.Bound == Int {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -718,7 +718,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?), Component.Match == (W, C0), R.Bound == Int {
+  ) where Output == (Substring, C0?), Component.Output == (W, C0), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -726,7 +726,7 @@ extension Optionally {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -735,21 +735,21 @@ extension Optionally {
     public init<W, C0, C1, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?)> where Component.Match == (W, C0, C1) {
+) -> Optionally<(Substring, C0?, C1?)> where Component.Output == (W, C0, C1) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?)> where Component.Match == (W, C0, C1) {
+  ) -> Regex<(Substring, C0?, C1?)> where Component.Output == (W, C0, C1) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -757,7 +757,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -766,14 +766,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?)> where Component.Match == (W, C0, C1) {
+) -> ZeroOrMore<(Substring, C0?, C1?)> where Component.Output == (W, C0, C1) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -782,7 +782,7 @@ extension OneOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -791,14 +791,14 @@ extension OneOrMore {
     public init<W, C0, C1, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0, C1), Component.Output == (W, C0, C1) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1)> where Component.Match == (W, C0, C1) {
+) -> OneOrMore<(Substring, C0, C1)> where Component.Output == (W, C0, C1) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -807,7 +807,7 @@ extension Repeat {
     public init<W, C0, C1, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -816,7 +816,7 @@ extension Repeat {
     public init<W, C0, C1, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1) {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -826,7 +826,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -834,7 +834,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?), Component.Match == (W, C0, C1), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?), Component.Output == (W, C0, C1), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -842,7 +842,7 @@ extension Optionally {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -851,21 +851,21 @@ extension Optionally {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?)> where Component.Match == (W, C0, C1, C2) {
+) -> Optionally<(Substring, C0?, C1?, C2?)> where Component.Output == (W, C0, C1, C2) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?)> where Component.Match == (W, C0, C1, C2) {
+  ) -> Regex<(Substring, C0?, C1?, C2?)> where Component.Output == (W, C0, C1, C2) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -873,7 +873,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -882,14 +882,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?)> where Component.Match == (W, C0, C1, C2) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?)> where Component.Output == (W, C0, C1, C2) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -898,7 +898,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -907,14 +907,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0, C1, C2), Component.Output == (W, C0, C1, C2) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2)> where Component.Match == (W, C0, C1, C2) {
+) -> OneOrMore<(Substring, C0, C1, C2)> where Component.Output == (W, C0, C1, C2) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -923,7 +923,7 @@ extension Repeat {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -932,7 +932,7 @@ extension Repeat {
     public init<W, C0, C1, C2, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -942,7 +942,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -950,7 +950,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?), Component.Match == (W, C0, C1, C2), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?), Component.Output == (W, C0, C1, C2), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -958,7 +958,7 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -967,21 +967,21 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, C3, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?, C3?)> where Component.Match == (W, C0, C1, C2, C3) {
+) -> Optionally<(Substring, C0?, C1?, C2?, C3?)> where Component.Output == (W, C0, C1, C2, C3) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?, C3?)> where Component.Match == (W, C0, C1, C2, C3) {
+  ) -> Regex<(Substring, C0?, C1?, C2?, C3?)> where Component.Output == (W, C0, C1, C2, C3) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -989,7 +989,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -998,14 +998,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, C3, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?)> where Component.Match == (W, C0, C1, C2, C3) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?)> where Component.Output == (W, C0, C1, C2, C3) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -1014,7 +1014,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2, C3), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1023,14 +1023,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2, C3), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0, C1, C2, C3), Component.Output == (W, C0, C1, C2, C3) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, C3, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2, C3)> where Component.Match == (W, C0, C1, C2, C3) {
+) -> OneOrMore<(Substring, C0, C1, C2, C3)> where Component.Output == (W, C0, C1, C2, C3) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -1039,7 +1039,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -1048,7 +1048,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -1058,7 +1058,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -1066,7 +1066,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?), Component.Match == (W, C0, C1, C2, C3), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?), Component.Output == (W, C0, C1, C2, C3), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -1074,7 +1074,7 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -1083,21 +1083,21 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?)> where Component.Match == (W, C0, C1, C2, C3, C4) {
+) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?)> where Component.Output == (W, C0, C1, C2, C3, C4) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?)> where Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?)> where Component.Output == (W, C0, C1, C2, C3, C4) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -1105,7 +1105,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1114,14 +1114,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?)> where Component.Match == (W, C0, C1, C2, C3, C4) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?)> where Component.Output == (W, C0, C1, C2, C3, C4) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -1130,7 +1130,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2, C3, C4), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1139,14 +1139,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2, C3, C4), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4), Component.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2, C3, C4)> where Component.Match == (W, C0, C1, C2, C3, C4) {
+) -> OneOrMore<(Substring, C0, C1, C2, C3, C4)> where Component.Output == (W, C0, C1, C2, C3, C4) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -1155,7 +1155,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -1164,7 +1164,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -1174,7 +1174,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -1182,7 +1182,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Match == (W, C0, C1, C2, C3, C4), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?), Component.Output == (W, C0, C1, C2, C3, C4), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -1190,7 +1190,7 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -1199,21 +1199,21 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -1221,7 +1221,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1230,14 +1230,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -1246,7 +1246,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1255,14 +1255,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5)> where Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5)> where Component.Output == (W, C0, C1, C2, C3, C4, C5) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -1271,7 +1271,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -1280,7 +1280,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -1290,7 +1290,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -1298,7 +1298,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Match == (W, C0, C1, C2, C3, C4, C5), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?), Component.Output == (W, C0, C1, C2, C3, C4, C5), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -1306,7 +1306,7 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -1315,21 +1315,21 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -1337,7 +1337,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1346,14 +1346,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -1362,7 +1362,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1371,14 +1371,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -1387,7 +1387,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -1396,7 +1396,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -1406,7 +1406,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -1414,7 +1414,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -1422,7 +1422,7 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -1431,21 +1431,21 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -1453,7 +1453,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1462,14 +1462,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -1478,7 +1478,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1487,14 +1487,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -1503,7 +1503,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -1512,7 +1512,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -1522,7 +1522,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -1530,7 +1530,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -1538,7 +1538,7 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -1547,21 +1547,21 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -1569,7 +1569,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1578,14 +1578,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -1594,7 +1594,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1603,14 +1603,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -1619,7 +1619,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -1628,7 +1628,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -1638,7 +1638,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -1646,7 +1646,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -1654,7 +1654,7 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component.regex.root))
   }
 }
@@ -1663,21 +1663,21 @@ extension Optionally {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .quantification(.zeroOrOne, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .?<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
   _ component: Component
-) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+) -> Optionally<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
   .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
 }
 
 extension RegexComponentBuilder {
   public static func buildLimitedAvailability<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component
-  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> Regex<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: .quantification(.zeroOrOne, .eager, component.regex.root))
   }
 }
@@ -1685,7 +1685,7 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1694,14 +1694,14 @@ extension ZeroOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .quantification(.zeroOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .*<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
   _ component: Component
-) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+) -> ZeroOrMore<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
   .init(node: .quantification(.zeroOrMore, .eager, component.regex.root))
 }
 
@@ -1710,7 +1710,7 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component.regex.root))
   }
 }
@@ -1719,14 +1719,14 @@ extension OneOrMore {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .quantification(.oneOrMore, behavior.astKind, component().regex.root))
   }
 }
 
 public postfix func .+<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
   _ component: Component
-) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)> where Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+) -> OneOrMore<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)> where Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
   .init(node: .quantification(.oneOrMore, .eager, component.regex.root))
 }
 
@@ -1735,7 +1735,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     _ component: Component,
     count: Int
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component.regex.root))
@@ -1744,7 +1744,7 @@ extension Repeat {
     public init<W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, Component: RegexComponent>(
     count: Int,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     assert(count > 0, "Must specify a positive count")
     // TODO: Emit a warning about `repeatMatch(count: 0)` or `repeatMatch(count: 1)`
     self.init(node: .quantification(.exactly(.init(faking: count)), .eager, component().regex.root))
@@ -1754,7 +1754,7 @@ extension Repeat {
     _ component: Component,
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component.regex.root))
   }
 
@@ -1762,7 +1762,7 @@ extension Repeat {
     _ expression: R,
     _ behavior: QuantificationBehavior = .eagerly,
     @RegexComponentBuilder _ component: () -> Component
-  ) where Match == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Bound == Int {
+  ) where Output == (Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?), Component.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Bound == Int {
     self.init(node: .repeating(expression.relative(to: 0..<Int.max), behavior, component().regex.root))
   }
 }
@@ -1780,754 +1780,754 @@ public func | <R0, R1>(lhs: R0, rhs: R1) -> ChoiceOf<Substring> where R0: RegexC
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0) {
+  ) -> ChoiceOf<(Substring, C0?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0) {
+public func | <R0, R1, W1, C0>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1) {
+  ) -> ChoiceOf<(Substring, C0?, C1?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1) {
+public func | <R0, R1, W1, C0, C1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2) {
+public func | <R0, R1, W1, C0, C1, C2>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2, C3>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3) {
+public func | <R0, R1, W1, C0, C1, C2, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2, C3, C4>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4) {
+public func | <R0, R1, W1, C0, C1, C2, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2, C3, C4, C5>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5) {
+public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2, C3, C4, C5, C6>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6) {
+public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7) {
+public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R1.Match == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+public func | <R0, R1, W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R1.Output == (W1, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0) {
+  ) -> ChoiceOf<(Substring, C0)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0) {
+public func | <R0, W0, C0, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1) {
+  ) -> ChoiceOf<(Substring, C0, C1?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1) {
+public func | <R0, W0, C0, R1, W1, C1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2) {
+public func | <R0, W0, C0, R1, W1, C1, C2>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2, C3>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3) {
+public func | <R0, W0, C0, R1, W1, C1, C2, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2, C3, C4>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4) {
+public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2, C3, C4, C5>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5) {
+public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6) {
+public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7) {
+public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8) {
+public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0), R1.Match == (W1, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+public func | <R0, W0, C0, R1, W1, C1, C2, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0), R1.Output == (W1, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1) {
+  ) -> ChoiceOf<(Substring, C0, C1)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1) {
+public func | <R0, W0, C0, C1, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2) {
+public func | <R0, W0, C0, C1, R1, W1, C2>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2, C3>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3) {
+public func | <R0, W0, C0, C1, R1, W1, C2, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2, C3, C4>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4) {
+public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2, C3, C4, C5>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5) {
+public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6) {
+public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7) {
+public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8) {
+public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1), R1.Match == (W1, C2, C3, C4, C5, C6, C7, C8, C9) {
+public func | <R0, W0, C0, C1, R1, W1, C2, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1), R1.Output == (W1, C2, C3, C4, C5, C6, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2) {
+public func | <R0, W0, C0, C1, C2, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1, W1, C3>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1, W1, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3) {
+public func | <R0, W0, C0, C1, C2, R1, W1, C3>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1, W1, C3, C4>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4) {
+public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1, W1, C3, C4, C5>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5) {
+public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6) {
+public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7) {
+public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8) {
+public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2), R1.Match == (W1, C3, C4, C5, C6, C7, C8, C9) {
+public func | <R0, W0, C0, C1, C2, R1, W1, C3, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2), R1.Output == (W1, C3, C4, C5, C6, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3) {
+public func | <R0, W0, C0, C1, C2, C3, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, R1, W1, C4>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4) {
+public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, R1, W1, C4, C5>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5) {
+public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6) {
+public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7) {
+public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8) {
+public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3), R1.Match == (W1, C4, C5, C6, C7, C8, C9) {
+public func | <R0, W0, C0, C1, C2, C3, R1, W1, C4, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4?, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3), R1.Output == (W1, C4, C5, C6, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4) {
+public func | <R0, W0, C0, C1, C2, C3, C4, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, R1, W1, C5>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5) {
+public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6) {
+public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7) {
+public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8) {
+public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4), R1.Match == (W1, C5, C6, C7, C8, C9) {
+public func | <R0, W0, C0, C1, C2, C3, C4, R1, W1, C5, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5?, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4), R1.Output == (W1, C5, C6, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5), R1.Match == (W1, C6, C7, C8, C9) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, R1, W1, C6, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6?, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5), R1.Output == (W1, C6, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Match == (W1, C7, C8, C9) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, R1, W1, C7, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7?, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6), R1.Output == (W1, C7, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1, W1, C8>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Output == (W1, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1, W1, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1, W1, C8>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Output == (W1, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1, W1, C8, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Output == (W1, C8, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1, W1, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Match == (W1, C8, C9) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, R1, W1, C8, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8?, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7), R1.Output == (W1, C8, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R1>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R1>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
   public static func buildPartialBlock<R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R1, W1, C9>(
     accumulated: R0, next: R1
-  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8), R1.Match == (W1, C9) {
+  ) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8), R1.Output == (W1, C9) {
     .init(node: accumulated.regex.root.appendingAlternationCase(next.regex.root))
   }
 }
 
-public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R1, W1, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Match == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8), R1.Match == (W1, C9) {
+public func | <R0, W0, C0, C1, C2, C3, C4, C5, C6, C7, C8, R1, W1, C9>(lhs: R0, rhs: R1) -> ChoiceOf<(Substring, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9?)> where R0: RegexComponent, R1: RegexComponent, R0.Output == (W0, C0, C1, C2, C3, C4, C5, C6, C7, C8), R1.Output == (W1, C9) {
   .init(node: lhs.regex.root.appendingAlternationCase(rhs.regex.root))
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0>(first regex: R) -> ChoiceOf<(W, C0?)> where R: RegexComponent, R.Match == (W, C0) {
+  public static func buildPartialBlock<R, W, C0>(first regex: R) -> ChoiceOf<(W, C0?)> where R: RegexComponent, R.Output == (W, C0) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1>(first regex: R) -> ChoiceOf<(W, C0?, C1?)> where R: RegexComponent, R.Match == (W, C0, C1) {
+  public static func buildPartialBlock<R, W, C0, C1>(first regex: R) -> ChoiceOf<(W, C0?, C1?)> where R: RegexComponent, R.Output == (W, C0, C1) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?)> where R: RegexComponent, R.Match == (W, C0, C1, C2) {
+  public static func buildPartialBlock<R, W, C0, C1, C2>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?)> where R: RegexComponent, R.Output == (W, C0, C1, C2) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2, C3>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?)> where R: RegexComponent, R.Match == (W, C0, C1, C2, C3) {
+  public static func buildPartialBlock<R, W, C0, C1, C2, C3>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?)> where R: RegexComponent, R.Output == (W, C0, C1, C2, C3) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?)> where R: RegexComponent, R.Match == (W, C0, C1, C2, C3, C4) {
+  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?)> where R: RegexComponent, R.Output == (W, C0, C1, C2, C3, C4) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?)> where R: RegexComponent, R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?)> where R: RegexComponent, R.Output == (W, C0, C1, C2, C3, C4, C5) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where R: RegexComponent, R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?)> where R: RegexComponent, R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6, C7>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R: RegexComponent, R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6, C7>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?)> where R: RegexComponent, R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6, C7, C8>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R: RegexComponent, R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6, C7, C8>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?)> where R: RegexComponent, R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
 extension AlternationBuilder {
-  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R: RegexComponent, R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  public static func buildPartialBlock<R, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(first regex: R) -> ChoiceOf<(W, C0?, C1?, C2?, C3?, C4?, C5?, C6?, C7?, C8?, C9?)> where R: RegexComponent, R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     .init(node: .orderedChoice([regex.regex.root]))
   }
 }
@@ -2537,14 +2537,14 @@ extension Capture {
   @_disfavoredOverload
   public init<R: RegexComponent, W>(
     _ component: R
-  ) where Match == (Substring, W), R.Match == W {
+  ) where Output == (Substring, W), R.Output == W {
     self.init(node: .capture(component.regex.root))
   }
 
   @_disfavoredOverload
   public init<R: RegexComponent, W>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W), R.Match == W {
+  ) where Output == (Substring, W), R.Output == W {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
@@ -2552,7 +2552,7 @@ extension Capture {
   public init<R: RegexComponent, W, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -2565,7 +2565,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2581,7 +2581,7 @@ extension TryCapture {
   public init<R: RegexComponent, W, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -2594,7 +2594,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2608,7 +2608,7 @@ extension TryCapture {
   public init<R: RegexComponent, W, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -2621,7 +2621,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2638,7 +2638,7 @@ extension Capture {
   @_disfavoredOverload
   public init<R: RegexComponent, W>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W), R.Match == W {
+  ) where Output == (Substring, W), R.Output == W {
     self.init(node: .capture(component().regex.root))
   }
 
@@ -2646,7 +2646,7 @@ extension Capture {
   public init<R: RegexComponent, W>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W), R.Match == W {
+  ) where Output == (Substring, W), R.Output == W {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -2656,7 +2656,7 @@ extension Capture {
   public init<R: RegexComponent, W, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -2669,7 +2669,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2685,7 +2685,7 @@ extension TryCapture {
   public init<R: RegexComponent, W, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -2698,7 +2698,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2712,7 +2712,7 @@ extension TryCapture {
   public init<R: RegexComponent, W, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -2725,7 +2725,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture), R.Match == W {
+  ) where Output == (Substring, NewCapture), R.Output == W {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2741,20 +2741,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0>(
     _ component: R
-  ) where Match == (Substring, W, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, W, C0), R.Output == (W, C0) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, W, C0), R.Output == (W, C0) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -2766,7 +2766,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2781,7 +2781,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -2793,7 +2793,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2806,7 +2806,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -2818,7 +2818,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2834,14 +2834,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, W, C0), R.Output == (W, C0) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, W, C0), R.Output == (W, C0) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -2850,7 +2850,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -2862,7 +2862,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2877,7 +2877,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -2889,7 +2889,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2902,7 +2902,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -2914,7 +2914,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0), R.Match == (W, C0) {
+  ) where Output == (Substring, NewCapture, C0), R.Output == (W, C0) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2930,20 +2930,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, W, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, W, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -2955,7 +2955,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2970,7 +2970,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -2982,7 +2982,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -2995,7 +2995,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3007,7 +3007,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3023,14 +3023,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, W, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, W, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -3039,7 +3039,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3051,7 +3051,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3066,7 +3066,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3078,7 +3078,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3091,7 +3091,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3103,7 +3103,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1), R.Match == (W, C0, C1) {
+  ) where Output == (Substring, NewCapture, C0, C1), R.Output == (W, C0, C1) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3119,20 +3119,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, W, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, W, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3144,7 +3144,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3159,7 +3159,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3171,7 +3171,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3184,7 +3184,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3196,7 +3196,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3212,14 +3212,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, W, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, W, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -3228,7 +3228,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3240,7 +3240,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3255,7 +3255,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3267,7 +3267,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3280,7 +3280,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3292,7 +3292,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2), R.Match == (W, C0, C1, C2) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2), R.Output == (W, C0, C1, C2) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3308,20 +3308,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, W, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, W, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3333,7 +3333,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3348,7 +3348,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3360,7 +3360,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3373,7 +3373,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3385,7 +3385,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3401,14 +3401,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, W, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, W, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -3417,7 +3417,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3429,7 +3429,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3444,7 +3444,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3456,7 +3456,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3469,7 +3469,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3481,7 +3481,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3), R.Match == (W, C0, C1, C2, C3) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3), R.Output == (W, C0, C1, C2, C3) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3497,20 +3497,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3522,7 +3522,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3537,7 +3537,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3549,7 +3549,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3562,7 +3562,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3574,7 +3574,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3590,14 +3590,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -3606,7 +3606,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3618,7 +3618,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3633,7 +3633,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3645,7 +3645,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3658,7 +3658,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3670,7 +3670,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Match == (W, C0, C1, C2, C3, C4) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4), R.Output == (W, C0, C1, C2, C3, C4) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3686,20 +3686,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3711,7 +3711,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3726,7 +3726,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3738,7 +3738,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3751,7 +3751,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3763,7 +3763,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3779,14 +3779,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -3795,7 +3795,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3807,7 +3807,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3822,7 +3822,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3834,7 +3834,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3847,7 +3847,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3859,7 +3859,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Match == (W, C0, C1, C2, C3, C4, C5) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5), R.Output == (W, C0, C1, C2, C3, C4, C5) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3875,20 +3875,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3900,7 +3900,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3915,7 +3915,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -3927,7 +3927,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3940,7 +3940,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -3952,7 +3952,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -3968,14 +3968,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -3984,7 +3984,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -3996,7 +3996,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4011,7 +4011,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -4023,7 +4023,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4036,7 +4036,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -4048,7 +4048,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Match == (W, C0, C1, C2, C3, C4, C5, C6) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6), R.Output == (W, C0, C1, C2, C3, C4, C5, C6) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4064,20 +4064,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -4089,7 +4089,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4104,7 +4104,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -4116,7 +4116,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4129,7 +4129,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -4141,7 +4141,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4157,14 +4157,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -4173,7 +4173,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -4185,7 +4185,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4200,7 +4200,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -4212,7 +4212,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4225,7 +4225,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -4237,7 +4237,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4253,20 +4253,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -4278,7 +4278,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4293,7 +4293,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -4305,7 +4305,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4318,7 +4318,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -4330,7 +4330,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4346,14 +4346,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -4362,7 +4362,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -4374,7 +4374,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4389,7 +4389,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -4401,7 +4401,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4414,7 +4414,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -4426,7 +4426,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4442,20 +4442,20 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(
     _ component: R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(
     _ component: R, as reference: Reference<W>
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(reference: reference.id, component.regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -4467,7 +4467,7 @@ extension Capture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4482,7 +4482,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -4494,7 +4494,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4507,7 +4507,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, NewCapture>(
     _ component: R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -4519,7 +4519,7 @@ extension TryCapture {
     _ component: R,
     as reference: Reference<NewCapture>,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4535,14 +4535,14 @@ extension TryCapture {
 extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(component().regex.root))
   }
 
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>(
     as reference: Reference<W>,
     @RegexComponentBuilder _ component: () -> R
-  ) where Match == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(
       reference: reference.id,
       component().regex.root))
@@ -4551,7 +4551,7 @@ extension Capture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any
@@ -4563,7 +4563,7 @@ extension Capture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4578,7 +4578,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         try transform($0) as Any
@@ -4590,7 +4590,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) throws -> NewCapture
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
@@ -4603,7 +4603,7 @@ extension TryCapture {
     public init<R: RegexComponent, W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, NewCapture>(
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(.transform(
       CaptureTransform(resultType: NewCapture.self) {
         transform($0) as Any?
@@ -4615,7 +4615,7 @@ extension TryCapture {
     as reference: Reference<NewCapture>,
     @RegexComponentBuilder _ component: () -> R,
     transform: @escaping (Substring) -> NewCapture?
-  ) where Match == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Match == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
+  ) where Output == (Substring, NewCapture, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9), R.Output == (W, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9) {
     self.init(node: .capture(
       reference: reference.id,
       .transform(
diff --git a/Tests/RegexTests/CustomTests.swift b/Tests/RegexTests/CustomTests.swift
index 6af14262b..12d4ad6cd 100644
--- a/Tests/RegexTests/CustomTests.swift
+++ b/Tests/RegexTests/CustomTests.swift
@@ -3,7 +3,7 @@ import XCTest
 
 // A nibbler processes a single character from a string
 private protocol Nibbler: CustomRegexComponent {
-  func nibble(_: Character) -> Match?
+  func nibble(_: Character) -> Output?
 }
 
 extension Nibbler {
@@ -12,7 +12,7 @@ extension Nibbler {
     _ input: String,
     startingAt index: String.Index,
     in bounds: Range<String.Index>
-  ) -> (upperBound: String.Index, match: Match)? {
+  ) -> (upperBound: String.Index, output: Output)? {
     guard index != bounds.upperBound, let res = nibble(input[index]) else {
       return nil
     }
@@ -23,7 +23,7 @@ extension Nibbler {
 
 // A number nibbler
 private struct Numbler: Nibbler {
-  typealias Match = Int
+  typealias Output = Int
   func nibble(_ c: Character) -> Int? {
     c.wholeNumberValue
   }
@@ -31,7 +31,7 @@ private struct Numbler: Nibbler {
 
 // An ASCII value nibbler
 private struct Asciibbler: Nibbler {
-  typealias Match = UInt8
+  typealias Output = UInt8
   func nibble(_ c: Character) -> UInt8? {
     c.asciiValue
   }
@@ -50,7 +50,7 @@ func customTest<Match: Equatable>(
     let result: Match?
     switch call {
     case .match:
-      result = input.match(regex)?.match
+      result = input.match(regex)?.output
     case .firstMatch:
       result = input.firstMatch(of: regex)?.result
     }
diff --git a/Tests/RegexTests/RegexDSLTests.swift b/Tests/RegexTests/RegexDSLTests.swift
index 8c71a6f31..4e954da24 100644
--- a/Tests/RegexTests/RegexDSLTests.swift
+++ b/Tests/RegexTests/RegexDSLTests.swift
@@ -33,12 +33,12 @@ class RegexDSLTests: XCTestCase {
       if let expectedCaptures = maybeExpectedCaptures {
         let match = try XCTUnwrap(maybeMatch, file: file, line: line)
         XCTAssertTrue(
-          type(of: regex).Match.self == MatchType.self,
+          type(of: regex).Output.self == MatchType.self,
           """
           Expected match type: \(MatchType.self)
-          Actual match type: \(type(of: regex).Match.self)
+          Actual match type: \(type(of: regex).Output.self)
           """)
-        let captures = try XCTUnwrap(match.match as? MatchType, file: file, line: line)
+        let captures = try XCTUnwrap(match.output as? MatchType, file: file, line: line)
         XCTAssertTrue(
           equivalence(captures, expectedCaptures),
           "'\(captures)' is not equal to the expected '\(expectedCaptures)'.",
@@ -56,14 +56,14 @@ class RegexDSLTests: XCTestCase {
       TryCapture("1") { Int($0) } // Int
     }
     // Assert the inferred capture type.
-    let _: (Substring, Substring, Int).Type = type(of: regex).Match.self
+    let _: (Substring, Substring, Int).Type = type(of: regex).Output.self
     let maybeMatch = "ab1".match(regex)
     let match = try XCTUnwrap(maybeMatch)
-    XCTAssertTrue(match.match == ("ab1", "b", 1))
+    XCTAssertTrue(match.output == ("ab1", "b", 1))
 
     let substring = "ab1"[...]
     let substringMatch = try XCTUnwrap(substring.match(regex))
-    XCTAssertTrue(match.match == substringMatch.match)
+    XCTAssertTrue(match.output == substringMatch.output)
   }
 
   func testCharacterClasses() throws {
@@ -87,8 +87,8 @@ class RegexDSLTests: XCTestCase {
       let regex = ChoiceOf {
         "aaa"
       }
-      XCTAssertTrue("aaa".match(regex)?.match == "aaa")
-      XCTAssertNil("aab".match(regex)?.match)
+      XCTAssertTrue("aaa".match(regex)?.output == "aaa")
+      XCTAssertNil("aab".match(regex)?.output)
     }
     do {
       let regex = ChoiceOf {
@@ -96,10 +96,10 @@ class RegexDSLTests: XCTestCase {
         "bbb"
         "ccc"
       }
-      XCTAssertTrue("aaa".match(regex)?.match == "aaa")
-      XCTAssertNil("aab".match(regex)?.match)
-      XCTAssertTrue("bbb".match(regex)?.match == "bbb")
-      XCTAssertTrue("ccc".match(regex)?.match == "ccc")
+      XCTAssertTrue("aaa".match(regex)?.output == "aaa")
+      XCTAssertNil("aab".match(regex)?.output)
+      XCTAssertTrue("bbb".match(regex)?.output == "bbb")
+      XCTAssertTrue("ccc".match(regex)?.output == "ccc")
     }
     do {
       let regex = Regex {
@@ -112,7 +112,7 @@ class RegexDSLTests: XCTestCase {
         }.+
       }
       XCTAssertTrue(
-        try XCTUnwrap("abc".match(regex)?.match) == ("abc", "c"))
+        try XCTUnwrap("abc".match(regex)?.output) == ("abc", "c"))
     }
     do {
       let regex = ChoiceOf {
@@ -120,18 +120,18 @@ class RegexDSLTests: XCTestCase {
         "bbb"
         "ccc"
       }
-      XCTAssertTrue("aaa".match(regex)?.match == "aaa")
-      XCTAssertNil("aab".match(regex)?.match)
-      XCTAssertTrue("bbb".match(regex)?.match == "bbb")
-      XCTAssertTrue("ccc".match(regex)?.match == "ccc")
+      XCTAssertTrue("aaa".match(regex)?.output == "aaa")
+      XCTAssertNil("aab".match(regex)?.output)
+      XCTAssertTrue("bbb".match(regex)?.output == "bbb")
+      XCTAssertTrue("ccc".match(regex)?.output == "ccc")
     }
     do {
       let regex = ChoiceOf {
         Capture("aaa")
       }
       XCTAssertTrue(
-        try XCTUnwrap("aaa".match(regex)?.match) == ("aaa", "aaa"))
-      XCTAssertNil("aab".match(regex)?.match)
+        try XCTUnwrap("aaa".match(regex)?.output) == ("aaa", "aaa"))
+      XCTAssertNil("aab".match(regex)?.output)
     }
     do {
       let regex = ChoiceOf {
@@ -140,12 +140,12 @@ class RegexDSLTests: XCTestCase {
         Capture("ccc")
       }
       XCTAssertTrue(
-        try XCTUnwrap("aaa".match(regex)?.match) == ("aaa", "aaa", nil, nil))
+        try XCTUnwrap("aaa".match(regex)?.output) == ("aaa", "aaa", nil, nil))
       XCTAssertTrue(
-        try XCTUnwrap("bbb".match(regex)?.match) == ("bbb", nil, "bbb", nil))
+        try XCTUnwrap("bbb".match(regex)?.output) == ("bbb", nil, "bbb", nil))
       XCTAssertTrue(
-        try XCTUnwrap("ccc".match(regex)?.match) == ("ccc", nil, nil, "ccc"))
-      XCTAssertNil("aab".match(regex)?.match)
+        try XCTUnwrap("ccc".match(regex)?.output) == ("ccc", nil, nil, "ccc"))
+      XCTAssertNil("aab".match(regex)?.output)
     }
   }
 
@@ -338,9 +338,9 @@ class RegexDSLTests: XCTestCase {
     // void.
     let regex = ZeroOrMore(.digit)
     // Assert the inferred capture type.
-    let _: Substring.Type = type(of: regex).Match.self
+    let _: Substring.Type = type(of: regex).Output.self
     let input = "123123"
-    let match = try XCTUnwrap(input.match(regex)?.match)
+    let match = try XCTUnwrap(input.match(regex)?.output)
     XCTAssertTrue(match == input)
   }
 
@@ -387,7 +387,7 @@ class RegexDSLTests: XCTestCase {
       }
     }
     let _: (Substring, Substring, Substring).Type
-      = type(of: regex1).Match.self
+      = type(of: regex1).Output.self
     let regex2 = Regex {
       "a".+
       Capture {
@@ -396,7 +396,7 @@ class RegexDSLTests: XCTestCase {
       }
     }
     let _: (Substring, Substring, Int?).Type
-      = type(of: regex2).Match.self
+      = type(of: regex2).Output.self
     let regex3 = Regex {
       "a".+
       Capture {
@@ -408,7 +408,7 @@ class RegexDSLTests: XCTestCase {
       }
     }
     let _: (Substring, Substring, Int, Double?).Type
-      = type(of: regex3).Match.self
+      = type(of: regex3).Output.self
     let regex4 = Regex {
       "a".+
       Capture {
@@ -422,7 +422,7 @@ class RegexDSLTests: XCTestCase {
     }
     let _: (
       Substring, Substring, Substring, Substring, Substring?).Type
-      = type(of: regex4).Match.self
+      = type(of: regex4).Output.self
   }
 
   func testUnicodeScalarPostProcessing() throws {
@@ -461,7 +461,7 @@ class RegexDSLTests: XCTestCase {
     }
 
     // Assert the inferred capture type.
-    let _: (Substring, Substring).Type = type(of: unicodeData).Match.self
+    let _: (Substring, Substring).Type = type(of: unicodeData).Output.self
 
     let unicodeLine =
       "1BCA0..1BCA3  ; Control # Cf   [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP"
@@ -496,10 +496,10 @@ class RegexDSLTests: XCTestCase {
       typealias ExpectedMatch = (
         Substring, Unicode.Scalar?, Unicode.Scalar??, Substring
       )
-      let _: ExpectedMatch.Type = type(of: regexWithCapture).Match.self
+      let _: ExpectedMatch.Type = type(of: regexWithCapture).Output.self
       let maybeMatchResult = line.match(regexWithCapture)
       let matchResult = try XCTUnwrap(maybeMatchResult)
-      let (wholeMatch, lower, upper, propertyString) = matchResult.match
+      let (wholeMatch, lower, upper, propertyString) = matchResult.output
       XCTAssertEqual(wholeMatch, Substring(line))
       XCTAssertEqual(lower, Unicode.Scalar(0xA6F0))
       XCTAssertEqual(upper, Unicode.Scalar(0xA6F1))
@@ -531,10 +531,10 @@ class RegexDSLTests: XCTestCase {
       typealias ExpectedMatch = (
         Substring, Unicode.Scalar, Unicode.Scalar?, Substring
       )
-      let _: ExpectedMatch.Type = type(of: regexWithTryCapture).Match.self
+      let _: ExpectedMatch.Type = type(of: regexWithTryCapture).Output.self
       let maybeMatchResult = line.match(regexWithTryCapture)
       let matchResult = try XCTUnwrap(maybeMatchResult)
-      let (wholeMatch, lower, upper, propertyString) = matchResult.match
+      let (wholeMatch, lower, upper, propertyString) = matchResult.output
       XCTAssertEqual(wholeMatch, Substring(line))
       XCTAssertEqual(lower, Unicode.Scalar(0xA6F0))
       XCTAssertEqual(upper, Unicode.Scalar(0xA6F1))
@@ -547,7 +547,7 @@ class RegexDSLTests: XCTestCase {
         matching: (Substring, Substring, Substring?, Substring).self)
       let maybeMatchResult = line.match(regexLiteral)
       let matchResult = try XCTUnwrap(maybeMatchResult)
-      let (wholeMatch, lower, upper, propertyString) = matchResult.match
+      let (wholeMatch, lower, upper, propertyString) = matchResult.output
       XCTAssertEqual(wholeMatch, Substring(line))
       XCTAssertEqual(lower, "A6F0")
       XCTAssertEqual(upper, "A6F1")
@@ -669,12 +669,12 @@ class RegexDSLTests: XCTestCase {
       var dev: String?
     }
     struct SemanticVersionParser: CustomRegexComponent {
-      typealias Match = SemanticVersion
+      typealias Output = SemanticVersion
       func match(
         _ input: String,
         startingAt index: String.Index,
         in bounds: Range<String.Index>
-      ) -> (upperBound: String.Index, match: SemanticVersion)? {
+      ) -> (upperBound: String.Index, output: SemanticVersion)? {
         let regex = Regex {
           TryCapture(OneOrMore(.digit)) { Int($0) }
           "."
@@ -710,7 +710,7 @@ class RegexDSLTests: XCTestCase {
     
     let parser = SemanticVersionParser()
     for (str, version) in versions {
-      XCTAssertEqual(str.match(parser)?.match, version)
+      XCTAssertEqual(str.match(parser)?.output, version)
     }
   }
 }