1932new RegexNode(RegexNodeKind.Empty, child.Options)); // single, so removing it yields empty 1978new(RegexNodeKind.One, multi.Options, multi.Str[1]) : 1979new(RegexNodeKind.Multi, multi.Options, multi.Str.Substring(1));

95new RegexNode(Kind, Options, Str!) : 96new RegexNode(Kind, Options, Ch); 121return new RegexNode(RegexNodeKind.One, options & ~RegexOptions.IgnoreCase, ch); 127return new RegexNode(RegexNodeKind.Set, options & ~RegexOptions.IgnoreCase, stringSet); 131return new RegexNode(RegexNodeKind.One, options, ch); 207RegexNode loopAsChild = new(RegexNodeKind.Loop, Options, M, N); 428parent.InsertChild(1, new RegexNode(RegexNodeKind.UpdateBumpalong, node.Options)); 501var atomic = new RegexNode(RegexNodeKind.Atomic, existingChild.Options); 6150 => new RegexNode(Kind == RegexNodeKind.Alternate ? RegexNodeKind.Nothing : RegexNodeKind.Empty, Options), 706return new RegexNode(RegexNodeKind.Empty, child.Options); 896return new RegexNode(RegexNodeKind.Nothing, Options); 935u = u.M == 0 ? new RegexNode(RegexNodeKind.Empty, Options) : child; 1023return new RegexNode(RegexNodeKind.Nothing, Options); 1245var newAlternate = new RegexNode(RegexNodeKind.Alternate, alternation.Options); 1256newAlternate.AddChild(new RegexNode(RegexNodeKind.Empty, children[i].Options)); 1263var atomic = new RegexNode(RegexNodeKind.Atomic, alternation.Options); 1270var newConcat = new RegexNode(RegexNodeKind.Concatenate, alternation.Options); 1421new RegexNode(RegexNodeKind.One, startingNodeOptions, startingSpan[0]) : 1422new RegexNode(RegexNodeKind.Multi, startingNodeOptions, startingSpan.ToString()); 1423var newAlternate = new RegexNode(RegexNodeKind.Alternate, startingNodeOptions); 1467var atomic = new RegexNode(RegexNodeKind.Atomic, startingNodeOptions); 1472var newConcat = new RegexNode(RegexNodeKind.Concatenate, startingNodeOptions); 1690return new RegexNode(RegexNodeKind.Empty, Options); 2292AddChild(new RegexNode(RegexNodeKind.Empty, Options)); 2310AddChild(new RegexNode(RegexNodeKind.Empty, Options)); 3111return new RegexNode(RegexNodeKind.Empty, Options); 3139var result = new RegexNode(lazy ? RegexNodeKind.Lazyloop : RegexNodeKind.Loop, Options, min, max);

277StartGroup(new RegexNode(RegexNodeKind.Capture, (_options & ~RegexOptions.IgnoreCase), 0, -1)); 347_unit = new RegexNode(RegexNodeKind.Set, _options & ~RegexOptions.IgnoreCase, setString); 394_unit = new RegexNode((_options & RegexOptions.Multiline) != 0 ? RegexNodeKind.Bol : RegexNodeKind.Beginning, _options); 398_unit = new RegexNode((_options & RegexOptions.Multiline) != 0 ? RegexNodeKind.Eol : RegexNodeKind.EndZ, _options); 403new RegexNode(RegexNodeKind.Set, _options & ~RegexOptions.IgnoreCase, RegexCharClass.AnyClass) : 404new RegexNode(RegexNodeKind.Notone, _options & ~RegexOptions.IgnoreCase, '\n'); 521_concatenation = new RegexNode(RegexNodeKind.Concatenate, _options); 806return new RegexNode(RegexNodeKind.Group, _options); 810return new RegexNode(RegexNodeKind.Capture, _options, _autocap++, -1); 984return new RegexNode(RegexNodeKind.Capture, _options, capnum, uncapnum); 1006return new RegexNode(RegexNodeKind.BackreferenceConditional, _options, capnum); 1020return new RegexNode(RegexNodeKind.BackreferenceConditional, _options, tmpCapnum); 1073return new RegexNode(nodeType, _options); 1138new RegexNode(TypeFromCode(ch), _options); 1143new RegexNode(RegexNodeKind.Set, (_options & ~RegexOptions.IgnoreCase), (_options & RegexOptions.ECMAScript) != 0 ? RegexCharClass.ECMAWordClass : RegexCharClass.WordClass); 1148new RegexNode(RegexNodeKind.Set, (_options & ~RegexOptions.IgnoreCase), (_options & RegexOptions.ECMAScript) != 0 ? RegexCharClass.NotECMAWordClass : RegexCharClass.NotWordClass); 1153new RegexNode(RegexNodeKind.Set, (_options & ~RegexOptions.IgnoreCase), (_options & RegexOptions.ECMAScript) != 0 ? RegexCharClass.ECMASpaceClass : RegexCharClass.SpaceClass); 1158new RegexNode(RegexNodeKind.Set, (_options & ~RegexOptions.IgnoreCase), (_options & RegexOptions.ECMAScript) != 0 ? RegexCharClass.NotECMASpaceClass : RegexCharClass.NotSpaceClass); 1163new RegexNode(RegexNodeKind.Set, (_options & ~RegexOptions.IgnoreCase), (_options & RegexOptions.ECMAScript) != 0 ? RegexCharClass.ECMADigitClass : RegexCharClass.DigitClass); 1168new RegexNode(RegexNodeKind.Set, (_options & ~RegexOptions.IgnoreCase), (_options & RegexOptions.ECMAScript) != 0 ? RegexCharClass.NotECMADigitClass : RegexCharClass.NotDigitClass); 1185return new RegexNode(RegexNodeKind.Set, (_options & ~RegexOptions.IgnoreCase), cc.ToStringClass()); 1250IsCaptureSlot(capnum) ? new RegexNode(RegexNodeKind.Backreference, _options, capnum) : 1282return scanOnly ? null : new RegexNode(RegexNodeKind.Backreference, _options, capnum); 1296return new RegexNode(RegexNodeKind.Backreference, _options, capnum); 1316_capnames?[capname] is int tmpCapnum ? new RegexNode(RegexNodeKind.Backreference, _options, tmpCapnum) : 1392return new RegexNode(RegexNodeKind.Backreference, _options, capnum); 1402return new RegexNode(RegexNodeKind.Backreference, _options, capnum); 1414return new RegexNode(RegexNodeKind.Backreference, _options, tmpCapnum); 1452return new RegexNode(RegexNodeKind.Backreference, _options, capnum); 2051_concatenation!.AddChild(new RegexNode(RegexNodeKind.Multi, _options & ~RegexOptions.IgnoreCase, _pattern.Substring(pos, cch))); 2097_alternation = new RegexNode(RegexNodeKind.Alternate, _options); 2098_concatenation = new RegexNode(RegexNodeKind.Concatenate, _options); 2115_concatenation = new RegexNode(RegexNodeKind.Concatenate, _options);

347RegexNode node = method.Tree.Root; 371static bool HasCaseInsensitiveBackReferences(RegexNode node)

755RegexNode root = rm.Tree.Root.Child(0); 1500(RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal) target = regexTree.FindOptimizations.LiteralAfterLoop.Value; 1622RegexNode node = regexTree.Root; 1803void EmitAlternation(RegexNode node) 1887RegexNode child = node.Child(i); 1888RegexNode? startingLiteralNode = child.FindStartingLiteralNode(allowZeroWidth: false); 1928RegexNode originalFirst = child.Child(0); 1974static RegexNode SliceOffMultiFirstChar(RegexNode multi) 2201void EmitBackreference(RegexNode node) 2270void EmitBackreferenceConditional(RegexNode node) 2284RegexNode yesBranch = node.Child(0); 2285RegexNode? noBranch = node.Child(1) is { Kind: not RegexNodeKind.Empty } childNo ? childNo : null; 2443void EmitExpressionConditional(RegexNode node) 2456RegexNode condition = node.Child(0); 2460RegexNode yesBranch = node.Child(1); 2461RegexNode? noBranch = node.Child(2) is { Kind: not RegexNodeKind.Empty } childNo ? childNo : null; 2623void EmitCapture(RegexNode node, RegexNode? subsequent = null) 2647RegexNode child = node.Child(0); 2716void EmitPositiveLookaroundAssertion(RegexNode node) 2757void EmitNegativeLookaroundAssertion(RegexNode node) 2788RegexNode child = node.Child(0); 2855void EmitNode(RegexNode node, RegexNode? subsequent = null, bool emitLengthChecksIfRequired = true) 3026void EmitAtomic(RegexNode node, RegexNode? subsequent) 3056void EmitUpdateBumpalong(RegexNode node) 3068void EmitConcatenation(RegexNode node, RegexNode? subsequent, bool emitLengthChecksIfRequired) 3106RegexNode child = node.Child(i); 3181static RegexNode? GetSubsequentOrDefault(int index, RegexNode node, RegexNode? defaultNode) 3186RegexNode next = node.Child(i); 3198void EmitSingleChar(RegexNode node, bool emitLengthCheck = true, string? offset = null, bool clauseOnly = false) 3242void EmitBoundary(RegexNode node) 3282void EmitAnchors(RegexNode node) 3348void EmitMultiChar(RegexNode node, bool emitLengthCheck) 3397void EmitSingleCharLoop(RegexNode node, RegexNode? subsequent = null, bool emitLengthChecksIfRequired = true) 3482subsequent?.FindStartingLiteralNode() is RegexNode literalNode && 3535void EmitSingleCharLazy(RegexNode node, RegexNode? subsequent = null, bool emitLengthChecksIfRequired = true) 3639subsequent?.FindStartingLiteral() is RegexNode.StartingLiteralData literal && 3707subsequent?.FindStartingLiteralNode() is RegexNode literal2 && 3782void EmitLazy(RegexNode node) 3789RegexNode child = node.Child(0); 4082void EmitSingleCharRepeater(RegexNode node, bool emitLengthCheck = true) 4100case <= RegexNode.MultiVsRepeaterLimit when node.IsOneFamily: 4202void EmitSingleCharAtomicLoop(RegexNode node, bool emitLengthChecksIfRequired = true) 4334void EmitAtomicSingleCharZeroOrOne(RegexNode node) 4372void EmitNonBacktrackingRepeater(RegexNode node) 4392void EmitLoop(RegexNode node) 4398RegexNode child = node.Child(0); 5010RegexNode node, 5535private static string DescribeNode(RegexNode node, RegexMethod rm) 5709private static void DescribeExpressionAsXmlComment(TextWriter writer, RegexNode node, RegexMethod rm, int depth = 0) 5779private static string DescribeLoop(RegexNode node, RegexMethod rm)

18public static RegexFindOptimizations Create(RegexNode root, RegexOptions options) 24RegexPrefixAnalyzer.FindLeadingPositiveLookahead(root) is RegexNode positiveLookahead) 46private RegexFindOptimizations(RegexNode root, RegexOptions options, bool isLeadingPartial) 202(RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? literalAfterLoop = RegexPrefixAnalyzer.FindLiteralFollowingLeadingLoop(root); 336public (RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? LiteralAfterLoop { get; }

19/// <remarks>null if no children, a <see cref="RegexNode"/> if one child, or a <see cref="List{RegexNode}"/> if multiple children.</remarks> 49public RegexNode? Parent; 87public RegexNode CloneCharLoopWithOneLessIteration() 94RegexNode newNode = IsSetFamily ? 110public static RegexNode CreateOneWithCaseConversion(char ch, RegexOptions options, CultureInfo? culture, ref RegexCaseBehavior caseBehavior) 135public RegexNode ReverseConcatenationIfRightToLeft() 141((List<RegexNode>)Children!).Reverse(); 207RegexNode loopAsChild = new(RegexNodeKind.Loop, Options, M, N); 245var toExamine = new Stack<RegexNode>(); 249RegexNode node = toExamine.Pop(); 255RegexNode child = node.Child(i); 369internal RegexNode FinalOptimize() 371RegexNode rootNode = this; 409RegexNode node = rootNode.Child(0); // skip implicit root capture node 462RegexNode node = this; 497RegexNode existingChild = node.Child(node.ChildCount() - 1); 501var atomic = new RegexNode(RegexNodeKind.Atomic, existingChild.Options); 574internal RegexNode Reduce() 610private RegexNode ReplaceNodeIfUnnecessary() 627private RegexNode ReduceGroup() 631RegexNode u = this; 648private RegexNode ReduceAtomic() 660RegexNode atomic = this; 661RegexNode child = Child(0); 698List<RegexNode>? branches = child.Children as List<RegexNode>; 739RegexNode startNode = branches[start]; 775RegexNode nextChild = branches[next]; 824private RegexNode ReduceLoops() 828RegexNode u = this; 836RegexNode child = u.Child(0); 904RegexNode child = u.Child(0); 955private RegexNode ReduceSet() 1016private RegexNode ReduceAlternation() 1030RegexNode node = ReplaceNodeIfUnnecessary(); 1075RegexNode at; 1076RegexNode prev; 1078List<RegexNode> children = (List<RegexNode>)Children!; 1090if (at.Children is List<RegexNode> atChildren) 1100RegexNode atChild = (RegexNode)at.Children!; 1184static RegexNode ExtractCommonPrefixNode(RegexNode alternation) 1187Debug.Assert(alternation.Children is List<RegexNode> { Count: >= 2 }); 1188var children = (List<RegexNode>)alternation.Children; 1204RegexNode startingNode = children[startingIndex]; 1205RegexNode required = startingNode.Kind == RegexNodeKind.Concatenate ? startingNode.Child(0) : startingNode; 1225RegexNode endingNode = children[endingIndex]; 1226RegexNode other = endingNode.Kind == RegexNodeKind.Concatenate ? endingNode.Child(0) : endingNode; 1245var newAlternate = new RegexNode(RegexNodeKind.Alternate, alternation.Options); 1250((List<RegexNode>)children[i].Children!).RemoveAt(0); 1261if (alternation.Parent is RegexNode { Kind: RegexNodeKind.Atomic }) 1263var atomic = new RegexNode(RegexNodeKind.Atomic, alternation.Options); 1270var newConcat = new RegexNode(RegexNodeKind.Concatenate, alternation.Options); 1284static RegexNode RemoveRedundantEmptiesAndNothings(RegexNode node) 1288var children = (List<RegexNode>)node.Children!; 1294RegexNode child = children[i]; 1327static RegexNode ExtractCommonPrefixText(RegexNode alternation) 1330Debug.Assert(alternation.Children is List<RegexNode> { Count: >= 2 }); 1331var children = (List<RegexNode>)alternation.Children; 1348RegexNode? startingNode = children[startingIndex].FindBranchOneOrMultiStart(); 1420var prefix = startingSpan.Length == 1 ? 1423var newAlternate = new RegexNode(RegexNodeKind.Alternate, startingNodeOptions); 1426RegexNode branch = children[i]; 1433static void ProcessOneOrMulti(RegexNode node, ReadOnlySpan<char> startingSpan) 1465if (alternation.Parent is RegexNode parent && parent.Kind == RegexNodeKind.Atomic) 1467var atomic = new RegexNode(RegexNodeKind.Atomic, startingNodeOptions); 1472var newConcat = new RegexNode(RegexNodeKind.Concatenate, startingNodeOptions); 1490public RegexNode? FindBranchOneOrMultiStart() 1492RegexNode branch = Kind == RegexNodeKind.Concatenate ? Child(0) : this; 1529if (Child(i).FindStartingLiteralNode(allowZeroWidth: false) is not RegexNode startingLiteralNode || 1575public RegexNode? FindStartingLiteralNode(bool allowZeroWidth = true) 1577RegexNode? node = this; 1615if (FindStartingLiteralNode() is RegexNode node) 1682private RegexNode ReduceConcatenation() 1699RegexNode child = Child(i); 1727Debug.Assert(Children is List<RegexNode>); 1733List<RegexNode> children = (List<RegexNode>)Children!; 1736RegexNode at = children[i]; 1746if (at.Children is List<RegexNode> atChildren) 1756RegexNode atChild = (RegexNode)at.Children!; 1774RegexNode prev = children[--j]; 1810Debug.Assert(Children is List<RegexNode>); 1812var children = (List<RegexNode>)Children!; 1817RegexNode currentNode = children[current]; 1818RegexNode nextNode = children[next]; 2018Debug.Assert(Children is List<RegexNode>); 2019var children = (List<RegexNode>)Children; 2024static void ProcessNode(RegexNode node, RegexNode subsequent) 2086RegexNode loopChild = node.Child(0); 2120RegexNode child = node.Child(0); 2130RegexNode child = node.Child(0); 2161private RegexNode ReduceLookaround() 2180static bool RemoveCaptures(RegexNode parent, int nodeIndex) 2182RegexNode node = parent.Child(nodeIndex); 2212RegexNode child = Child(0); 2251private static bool? ContainsKind(RegexNode node, ReadOnlySpan<RegexNodeKind> kinds) 2281private RegexNode ReduceBackreferenceConditional() 2299private RegexNode ReduceExpressionConditional() 2318RegexNode condition = Child(0); 2337private static bool CanBeMadeAtomic(RegexNode node, RegexNode subsequent, bool iterateNullableSubsequent, bool allowLazy) 2502RegexNode loopChild = node.Child(0); 2557RegexNode? parent = subsequent.Parent; 2567var peers = (List<RegexNode>)parent.Children!; 2614private static bool MayContainBacktracking(RegexNode node) 2650RegexNode node = this; 2657node.Parent is not RegexNode parent) 2671var peers = (List<RegexNode>)parent.Children!; 2971RegexNode child = Child(i); 3063static bool CanJoinLengthCheck(RegexNode node) => node.Kind switch 3074RegexNode child = Child(childIndex); 3102public RegexNode MakeQuantifier(bool lazy, int min, int max) 3139var result = new RegexNode(lazy ? RegexNodeKind.Lazyloop : RegexNodeKind.Loop, Options, min, max); 3145public void AddChild(RegexNode newChild) 3155else if (Children is RegexNode currentChild) 3157Children = new List<RegexNode>() { currentChild, newChild }; 3161((List<RegexNode>)Children).Add(newChild); 3165public void InsertChild(int index, RegexNode newChild) 3167Debug.Assert(Children is List<RegexNode>); 3173((List<RegexNode>)Children).Insert(index, newChild); 3176public void ReplaceChild(int index, RegexNode newChild) 3185if (Children is RegexNode) 3191((List<RegexNode>)Children)[index] = newChild; 3195public RegexNode Child(int i) => Children is RegexNode child ? child : ((List<RegexNode>)Children!)[i]; 3204if (Children is List<RegexNode> children) 3209Debug.Assert(Children is RegexNode); 3240static bool ExceedsMaxDepthAllowedDepth(RegexNode node, int allowedDepth) 3274RegexNode? curNode = this;

6/// <summary>Specifies the kind of a <see cref="RegexNode"/>.</summary> 16/// <remarks>The character is specified in <see cref="RegexNode.Ch"/>.</remarks> 19/// <remarks>The character is specified in <see cref="RegexNode.Ch"/>.</remarks> 22/// <remarks>The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>.</remarks> 26/// <remarks>The characters are specified in <see cref="RegexNode.Str"/>. This is purely a representational optimization, equivalent to multiple <see cref="One"/> nodes concatenated together.</remarks> 31/// The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>. 36/// <remarks>The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks> 40/// <remarks>The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks> 45/// <remarks>The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks> 49/// <remarks>The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks> 53/// <remarks>The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>.</remarks> 59/// The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>. 65/// The character is specified in <see cref="RegexNode.Ch"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>. 71/// The <see cref="RegexCharClass"/> set string is specified in <see cref="RegexNode.Str"/>, the minimum number of iterations in <see cref="RegexNode.M"/>, and the maximum number of iterations in <see cref="RegexNode.N"/>. 77/// <remarks>The capture group number referenced is stored in <see cref="RegexNode.M"/>.</remarks> 126/// <summary>A loop around an arbitrary <see cref="RegexNode"/>, e.g. `(ab|cd)*`.</summary> 128/// One and only one child, the expression in the loop. The minimum number of iterations is in <see cref="RegexNode.M"/>, 129/// and the maximum number of iterations is in <see cref="RegexNode.N"/>. 132/// <summary>A lazy loop around an arbitrary <see cref="RegexNode"/>, e.g. `(ab|cd)*?`.</summary> 134/// One and only one child, the expression in the loop. The minimum number of iterations is in <see cref="RegexNode.M"/>, 135/// and the maximum number of iterations is in <see cref="RegexNode.N"/>. 141/// One and only one child, the expression in the capture. <see cref="RegexNode.M"/> is the number of the capture, and if a balancing 142/// group, <see cref="RegexNode.N"/> is the uncapture. 169/// The referenced capture group number is stored in <see cref="RegexNode.M"/>.

151/// For quantified constructs with a minimum of zero (<see cref="RegexNode.M"/> == 0), this opcode pushes a counter

24private RegexNode? _stack; 25private RegexNode? _group; 26private RegexNode? _alternation; 27private RegexNode? _concatenation; 28private RegexNode? _unit; 109RegexNode root = parser.ScanRegex(); 144RegexNode root = parser.ScanReplacement(); 270private RegexNode ScanRegex() 332_unit = RegexNode.CreateOneWithCaseConversion(_pattern[endpos - 1], _options, _culture, ref _caseBehavior); 353if (ScanGroupOpen() is RegexNode grouper) 519private RegexNode ScanReplacement() 795private RegexNode? ScanGroupOpen() 1123private RegexNode? ScanBackslash(bool scanOnly) 1188RegexNode? result = ScanBasicBackslash(scanOnly); 1198private RegexNode? ScanBasicBackslash(bool scanOnly) 1327RegexNode.CreateOneWithCaseConversion(ch, _options, _culture, ref _caseBehavior) : 1332private RegexNode ScanDollar() 1336return RegexNode.CreateOneWithCaseConversion('$', _options, _culture, ref _caseBehavior); 1426return RegexNode.CreateOneWithCaseConversion('$', _options, _culture, ref _caseBehavior); 1459return RegexNode.CreateOneWithCaseConversion('$', _options, _culture, ref _caseBehavior); 2047_concatenation!.AddChild(RegexNode.CreateOneWithCaseConversion(_pattern[pos], isReplacement ? _options & ~RegexOptions.IgnoreCase : _options, _culture, ref _caseBehavior)); 2057_concatenation!.AddChild(RegexNode.CreateOneWithCaseConversion(c, _options, _culture, ref _caseBehavior)); 2094private void StartGroup(RegexNode openGroup)

21public static string[]? FindPrefixes(RegexNode node, bool ignoreCase) 57static bool FindPrefixesCore(RegexNode node, List<StringBuilder> results, bool ignoreCase) 340public static string FindPrefix(RegexNode node) 348static bool Process(RegexNode node, ref ValueStringBuilder vsb) 483public static string? FindPrefixOrdinalCaseInsensitive(RegexNode node) 511public static List<RegexFindOptimizations.FixedDistanceSet>? FindFixedDistanceSets(RegexNode root, bool thorough) 586static bool TryFindRawFixedSets(RegexNode node, List<RegexFindOptimizations.FixedDistanceSet> results, ref int distance, bool thorough) 906public static string? FindFirstCharClass(RegexNode root) => FindFirstOrLastCharClass(root, findFirst: true); 911public static string? FindLastCharClass(RegexNode root) => FindFirstOrLastCharClass(root, findFirst: false); 913public static string? FindFirstOrLastCharClass(RegexNode root, bool findFirst) 942static bool? TryFindFirstOrLastCharClass(RegexNode node, bool findFirst, ref RegexCharClass? cc) 1127public static (RegexNode LoopNode, (char Char, string? String, StringComparison StringComparison, char[]? Chars) Literal)? FindLiteralFollowingLeadingLoop(RegexNode node) 1154RegexNode firstChild = node.Child(0); 1166RegexNode nextChild = node.Child(1); 1256public static RegexNode? FindLeadingPositiveLookahead(RegexNode node) 1258RegexNode? positiveLookahead = null; 1263static bool FindLeadingPositiveLookahead(RegexNode node, ref RegexNode? positiveLookahead) 1330public static RegexNodeKind FindLeadingAnchor(RegexNode node) => 1334public static RegexNodeKind FindTrailingAnchor(RegexNode node) => 1338private static RegexNodeKind FindLeadingOrTrailingAnchor(RegexNode node, bool leading) 1379RegexNode? child = null; 1385RegexNode tmpChild = node.Child(i);

11/// Provides the core data describing a parsed <see cref="RegexNode"/> tree, along with necessary 18/// <summary>The root node of the parsed <see cref="RegexNode"/> tree.</summary> 19public readonly RegexNode Root; 43internal RegexTree(RegexNode root, int captureCount, string[]? captureNames, Hashtable? captureNameToNumberMapping, Hashtable? captureNumberSparseMapping, RegexOptions options, CultureInfo? culture)

9/// <summary>Analyzes a <see cref="RegexTree"/> of <see cref="RegexNode"/>s to produce data on the tree structure, in particular in support of code generation.</summary> 19static bool TryAnalyze(RegexNode node, AnalysisResults results, bool isAtomicByAncestor, bool isInLoop) 33(results._inLoops ??= new HashSet<RegexNode>()).Add(node); 49(results._mayBacktrack ??= new HashSet<RegexNode>()).Add(node); 81RegexNode child = node.Child(i); 131(results._mayBacktrack ??= new HashSet<RegexNode>()).Add(node); 154internal readonly HashSet<RegexNode> _isAtomicByAncestor = new(); // since the root is implicitly atomic, every tree will contain atomic-by-ancestor nodes 156internal readonly HashSet<RegexNode> _containsCapture = new(); // the root is a capture, so this will always contain at least the root node 158internal HashSet<RegexNode>? _mayBacktrack; 160internal HashSet<RegexNode>? _inLoops; 179public bool IsAtomicByAncestor(RegexNode node) => _isAtomicByAncestor.Contains(node); 187public bool MayContainCapture(RegexNode node) => !_complete || _containsCapture.Contains(node); 200public bool MayBacktrack(RegexNode node) => !_complete || (_mayBacktrack?.Contains(node) ?? false); 220public bool IsInLoop(RegexNode node) => !_complete || (_inLoops?.Contains(node) ?? false);

108public RegexReplacement(string rep, RegexNode concat, Hashtable caps) { }