activerecord-ejection_seat 0.3.0 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (25) hide show
  1. checksums.yaml +4 -4
  2. data/.ruby-version +1 -1
  3. data/.tool-versions +1 -1
  4. data/CODE_OF_CONDUCT.md +1 -1
  5. data/Gemfile.lock +30 -30
  6. data/README.md +19 -8
  7. data/activerecord-ejection_seat.gemspec +3 -3
  8. data/lib/activerecord-ejection_seat/version.rb +1 -1
  9. data/sorbet/rbi/gems/{activemodel@7.0.4.1.rbi → activemodel@7.0.4.2.rbi} +0 -0
  10. data/sorbet/rbi/gems/{activerecord@7.0.4.1.rbi → activerecord@7.0.4.2.rbi} +128 -128
  11. data/sorbet/rbi/gems/{activesupport@7.0.4.1.rbi → activesupport@7.0.4.2.rbi} +1 -1
  12. data/sorbet/rbi/gems/{concurrent-ruby@1.1.10.rbi → concurrent-ruby@1.2.0.rbi} +1158 -1220
  13. data/sorbet/rbi/gems/irb@1.6.2.rbi +35 -50
  14. data/sorbet/rbi/gems/{language_server-protocol@3.17.0.2.rbi → language_server-protocol@3.17.0.3.rbi} +0 -0
  15. data/sorbet/rbi/gems/{parser@3.2.0.0.rbi → parser@3.2.1.0.rbi} +596 -307
  16. data/sorbet/rbi/gems/{regexp_parser@2.6.1.rbi → regexp_parser@2.7.0.rbi} +598 -144
  17. data/sorbet/rbi/gems/{rubocop-ast@1.24.1.rbi → rubocop-ast@1.26.0.rbi} +94 -94
  18. data/sorbet/rbi/gems/{rubocop-minitest@0.26.1.rbi → rubocop-minitest@0.27.0.rbi} +111 -45
  19. data/sorbet/rbi/gems/{rubocop-sorbet@0.6.11.rbi → rubocop-sorbet@0.7.0.rbi} +158 -114
  20. data/sorbet/rbi/gems/{rubocop@1.43.0.rbi → rubocop@1.45.1.rbi} +1339 -954
  21. data/sorbet/rbi/gems/{ruby-lsp@0.3.8.rbi → ruby-lsp@0.4.0.rbi} +0 -0
  22. data/sorbet/rbi/gems/{syntax_tree@5.2.0.rbi → syntax_tree@6.0.0.rbi} +0 -0
  23. data/sorbet/rbi/gems/tzinfo@2.0.6.rbi +5917 -0
  24. metadata +22 -22
  25. data/sorbet/rbi/gems/tzinfo@2.0.5.rbi +0 -8
data/sorbet/rbi/gems/{regexp_parser@2.6.1.rbi → regexp_parser@2.7.0.rbi} RENAMED
@@ -4,8 +4,10 @@
4
4
  # This is an autogenerated file for types exported from the `regexp_parser` gem.
5
5
  # Please instead update this file by running `bin/tapioca gem regexp_parser`.
6
6
 
7
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#1
7
8
  module Regexp::Expression; end
8
9
 
10
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#5
9
11
  class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
10
12
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
11
13
  def alternatives; end
@@ -13,7 +15,7 @@ class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
13
15
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#9
14
16
  def human_name; end
15
17
 
16
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#127
18
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
17
19
  def match_length; end
18
20
  end
19
21
 
@@ -21,11 +23,14 @@ end
21
23
  Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
22
24
 
23
25
  # A sequence of expressions, used by Alternation as one of its alternative.
26
+ #
27
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#3
24
28
  class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence
25
29
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#10
26
30
  def human_name; end
27
31
  end
28
32
 
33
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#2
29
34
  module Regexp::Expression::Anchor; end
30
35
 
31
36
  # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#18
@@ -34,16 +39,19 @@ Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
34
39
  # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#20
35
40
  Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
36
41
 
42
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#3
37
43
  class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
38
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
44
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
39
45
  def match_length; end
40
46
  end
41
47
 
48
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#5
42
49
  class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base
43
50
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#11
44
51
  def human_name; end
45
52
  end
46
53
 
54
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#8
47
55
  class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base
48
56
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#12
49
57
  def human_name; end
@@ -58,68 +66,83 @@ Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
58
66
  # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#22
59
67
  Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
60
68
 
69
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#6
61
70
  class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base
62
71
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#13
63
72
  def human_name; end
64
73
  end
65
74
 
75
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#9
66
76
  class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base
67
77
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#14
68
78
  def human_name; end
69
79
  end
70
80
 
81
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#11
71
82
  class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base
72
83
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#15
73
84
  def human_name; end
74
85
  end
75
86
 
87
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#16
76
88
  class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base
77
89
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#16
78
90
  def human_name; end
79
91
  end
80
92
 
93
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#14
81
94
  class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base
82
95
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#17
83
96
  def human_name; end
84
97
  end
85
98
 
99
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#13
86
100
  class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base
87
101
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#18
88
102
  def human_name; end
89
103
  end
90
104
 
105
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#86
91
106
  module Regexp::Expression::Assertion; end
92
107
 
108
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#87
93
109
  class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
94
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
110
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
95
111
  def match_length; end
96
112
  end
97
113
 
114
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#89
98
115
  class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base
99
116
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#19
100
117
  def human_name; end
101
118
  end
102
119
 
120
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#92
103
121
  class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base
104
122
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#20
105
123
  def human_name; end
106
124
  end
107
125
 
126
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#90
108
127
  class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base
109
128
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#21
110
129
  def human_name; end
111
130
  end
112
131
 
132
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#93
113
133
  class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base
114
134
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#22
115
135
  def human_name; end
116
136
  end
117
137
 
118
138
  # TODO: unify name with token :backref, one way or the other, in v3.0.0
139
+ #
140
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3
119
141
  module Regexp::Expression::Backreference; end
120
142
 
143
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4
121
144
  class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
122
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#151
145
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#155
123
146
  def match_length; end
124
147
 
125
148
  # Returns the value of attribute referenced_expression.
@@ -134,16 +157,22 @@ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
134
157
  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#5
135
158
  def referenced_expression=(_arg0); end
136
159
 
160
+ # @return [Boolean]
161
+ #
162
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
163
+ def referential?; end
164
+
137
165
  private
138
166
 
139
167
  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#7
140
168
  def initialize_copy(orig); end
141
169
  end
142
170
 
171
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#39
143
172
  class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
144
173
  # @return [Name] a new instance of Name
145
174
  #
146
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#27
175
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43
147
176
  def initialize(token, options = T.unsafe(nil)); end
148
177
 
149
178
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23
@@ -151,36 +180,39 @@ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backrefere
151
180
 
152
181
  # Returns the value of attribute name.
153
182
  #
154
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
183
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40
155
184
  def name; end
156
185
 
157
186
  # Returns the value of attribute name.
158
187
  #
159
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
188
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40
160
189
  def reference; end
161
190
  end
162
191
 
192
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#55
163
193
  class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
164
194
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24
165
195
  def human_name; end
166
196
  end
167
197
 
198
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#67
168
199
  class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
169
200
  # @return [NameRecursionLevel] a new instance of NameRecursionLevel
170
201
  #
171
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
202
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#70
172
203
  def initialize(token, options = T.unsafe(nil)); end
173
204
 
174
205
  # Returns the value of attribute recursion_level.
175
206
  #
176
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#52
207
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#68
177
208
  def recursion_level; end
178
209
  end
179
210
 
211
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#29
180
212
  class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
181
213
  # @return [Number] a new instance of Number
182
214
  #
183
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#17
215
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#33
184
216
  def initialize(token, options = T.unsafe(nil)); end
185
217
 
186
218
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25
@@ -188,48 +220,52 @@ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backrefe
188
220
 
189
221
  # Returns the value of attribute number.
190
222
  #
191
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#14
223
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30
192
224
  def number; end
193
225
 
194
226
  # Returns the value of attribute number.
195
227
  #
196
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#14
228
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30
197
229
  def reference; end
198
230
  end
199
231
 
232
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
200
233
  class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
201
234
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27
202
235
  def human_name; end
203
236
  end
204
237
 
238
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56
205
239
  class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
206
240
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28
207
241
  def human_name; end
208
242
  end
209
243
 
244
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#58
210
245
  class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative
211
246
  # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel
212
247
  #
213
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
248
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#61
214
249
  def initialize(token, options = T.unsafe(nil)); end
215
250
 
216
251
  # Returns the value of attribute recursion_level.
217
252
  #
218
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43
253
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#59
219
254
  def recursion_level; end
220
255
  end
221
256
 
257
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49
222
258
  class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
223
259
  # Returns the value of attribute effective_number.
224
260
  #
225
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
261
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
226
262
  def effective_number; end
227
263
 
228
264
  # Sets the attribute effective_number
229
265
  #
230
266
  # @param value the value to set the attribute effective_number to.
231
267
  #
232
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
268
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
233
269
  def effective_number=(_arg0); end
234
270
 
235
271
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26
@@ -237,13 +273,13 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::
237
273
 
238
274
  # Returns the value of attribute effective_number.
239
275
  #
240
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
276
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
241
277
  def reference; end
242
278
  end
243
279
 
280
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#2
244
281
  class Regexp::Expression::Base
245
282
  include ::Regexp::Expression::Shared
246
- include ::RuboCop::Ext::RegexpParser::Expression::Base
247
283
  extend ::Regexp::Expression::Shared::ClassMethods
248
284
 
249
285
  # @return [Base] a new instance of Base
@@ -518,9 +554,8 @@ class Regexp::Expression::Base
518
554
  def initialize_copy(orig); end
519
555
  end
520
556
 
557
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#2
521
558
  class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
522
- include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet
523
-
524
559
  # @return [CharacterSet] a new instance of CharacterSet
525
560
  #
526
561
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#9
@@ -546,7 +581,7 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
546
581
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
547
582
  def closed?; end
548
583
 
549
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
584
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
550
585
  def match_length; end
551
586
 
552
587
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#15
@@ -578,25 +613,28 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
578
613
  def parts; end
579
614
  end
580
615
 
616
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#3
581
617
  class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
582
618
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#29
583
619
  def human_name; end
584
620
 
585
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
621
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
586
622
  def match_length; end
587
623
  end
588
624
 
625
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#5
589
626
  class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
590
627
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#30
591
628
  def human_name; end
592
629
 
593
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
630
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
594
631
  def match_length; end
595
632
  end
596
633
 
597
634
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#6
598
635
  Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
599
636
 
637
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#3
600
638
  class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
601
639
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#9
602
640
  def <<(exp); end
@@ -609,7 +647,7 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
609
647
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31
610
648
  def human_name; end
611
649
 
612
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
650
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
613
651
  def match_length; end
614
652
 
615
653
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#19
@@ -622,46 +660,72 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
622
660
  def ts; end
623
661
  end
624
662
 
663
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#2
625
664
  module Regexp::Expression::CharacterType; end
626
665
 
666
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#5
627
667
  class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base
628
668
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#32
629
669
  def human_name; end
630
670
  end
631
671
 
672
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#3
632
673
  class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
633
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
674
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
634
675
  def match_length; end
635
676
  end
636
677
 
678
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#6
637
679
  class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
680
+
681
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#15
638
682
  class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
683
+
684
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#8
639
685
  class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
686
+
687
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#14
640
688
  class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
689
+
690
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#7
641
691
  class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
692
+
693
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#9
642
694
  class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
695
+
696
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#13
643
697
  class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
698
+
699
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#11
644
700
  class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
701
+
702
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#12
645
703
  class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
704
+
705
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#10
646
706
  class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
647
707
 
708
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#8
648
709
  class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace
649
710
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#33
650
711
  def human_name; end
651
712
  end
652
713
 
714
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2
653
715
  module Regexp::Expression::Conditional; end
654
716
 
717
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#29
655
718
  class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
656
719
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34
657
720
  def human_name; end
658
721
  end
659
722
 
723
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#9
660
724
  class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
661
725
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#35
662
726
  def human_name; end
663
727
 
664
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
728
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
665
729
  def match_length; end
666
730
 
667
731
  # Name or number of the referenced capturing group that determines state.
@@ -682,65 +746,77 @@ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
682
746
  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10
683
747
  def referenced_expression=(_arg0); end
684
748
 
749
+ # @return [Boolean]
750
+ #
751
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#24
752
+ def referential?; end
753
+
685
754
  private
686
755
 
687
756
  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#19
688
757
  def initialize_copy(orig); end
689
758
  end
690
759
 
760
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#31
691
761
  class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
692
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#30
762
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
693
763
  def <<(exp); end
694
764
 
695
765
  # @raise [TooManyBranches]
696
766
  #
697
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
767
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38
698
768
  def add_sequence(active_opts = T.unsafe(nil)); end
699
769
 
700
770
  # @raise [TooManyBranches]
701
771
  #
702
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
772
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38
703
773
  def branch(active_opts = T.unsafe(nil)); end
704
774
 
705
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
775
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
706
776
  def branches; end
707
777
 
708
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#46
778
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
709
779
  def condition; end
710
780
 
711
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41
781
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#45
712
782
  def condition=(exp); end
713
783
 
714
784
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36
715
785
  def human_name; end
716
786
 
717
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#127
787
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
718
788
  def match_length; end
719
789
 
720
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
790
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#66
721
791
  def parts; end
722
792
 
723
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
793
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
724
794
  def reference; end
725
795
 
726
796
  # Returns the value of attribute referenced_expression.
727
797
  #
728
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
798
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32
729
799
  def referenced_expression; end
730
800
 
731
801
  # Sets the attribute referenced_expression
732
802
  #
733
803
  # @param value the value to set the attribute referenced_expression to.
734
804
  #
735
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
805
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32
736
806
  def referenced_expression=(_arg0); end
737
807
 
808
+ # @return [Boolean]
809
+ #
810
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#62
811
+ def referential?; end
812
+
738
813
  private
739
814
 
740
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#62
815
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#70
741
816
  def initialize_copy(orig); end
742
817
  end
743
818
 
819
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#3
744
820
  class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
745
821
  # @return [TooManyBranches] a new instance of TooManyBranches
746
822
  #
@@ -749,8 +825,11 @@ class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
749
825
  end
750
826
 
751
827
  # TODO: unify naming with Token::Escape, one way or the other, in v3.0.0
828
+ #
829
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3
752
830
  module Regexp::Expression::EscapeSequence; end
753
831
 
832
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#64
754
833
  class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
755
834
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#65
756
835
  def char; end
@@ -764,9 +843,13 @@ class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp
764
843
  def meta_char_to_codepoint(meta_char); end
765
844
  end
766
845
 
846
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#28
767
847
  class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end
848
+
849
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29
768
850
  class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end
769
851
 
852
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#4
770
853
  class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
771
854
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#10
772
855
  def char; end
@@ -774,13 +857,17 @@ class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
774
857
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#5
775
858
  def codepoint; end
776
859
 
777
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
860
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
778
861
  def match_length; end
779
862
  end
780
863
 
864
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#30
781
865
  class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end
866
+
867
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#38
782
868
  class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end
783
869
 
870
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#40
784
871
  class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
785
872
  # @raise [NoMethodError]
786
873
  #
@@ -798,46 +885,61 @@ class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::
798
885
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#53
799
886
  def codepoints; end
800
887
 
801
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#160
888
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#164
802
889
  def match_length; end
803
890
  end
804
891
 
892
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#82
805
893
  class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
806
894
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#83
807
895
  def codepoint; end
808
896
  end
809
897
 
898
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#31
810
899
  class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end
900
+
901
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#37
811
902
  class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end
812
903
 
904
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22
813
905
  class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
814
906
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#23
815
907
  def char; end
816
908
  end
817
909
 
910
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#88
818
911
  class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
819
912
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#89
820
913
  def codepoint; end
821
914
  end
822
915
 
916
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#94
823
917
  class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
824
918
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#95
825
919
  def codepoint; end
826
920
  end
827
921
 
922
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#32
828
923
  class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end
829
924
 
925
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#58
830
926
  class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
831
927
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#59
832
928
  def char; end
833
929
  end
834
930
 
931
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#33
835
932
  class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end
933
+
934
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#34
836
935
  class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end
936
+
937
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#35
837
938
  class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end
838
939
 
940
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2
839
941
  class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
840
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
942
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
841
943
  def match_length; end
842
944
 
843
945
  # @raise [Regexp::Parser::Error]
@@ -846,17 +948,22 @@ class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
846
948
  def quantify(*_args); end
847
949
  end
848
950
 
951
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#2
849
952
  module Regexp::Expression::Group; end
850
953
 
851
954
  # Special case. Absence group can match 0.. chars, irrespective of content.
852
955
  # TODO: in theory, they *can* exclude match lengths with `.`: `(?~.{3})`
956
+ #
957
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#34
853
958
  class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
854
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#168
959
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#172
855
960
  def match_length; end
856
961
  end
857
962
 
963
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#35
858
964
  class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
859
965
 
966
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#3
860
967
  class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
861
968
  # @return [Boolean]
862
969
  #
@@ -872,6 +979,7 @@ class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
872
979
  def parts; end
873
980
  end
874
981
 
982
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#55
875
983
  class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
876
984
  # @return [Boolean]
877
985
  #
@@ -911,6 +1019,7 @@ class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
911
1019
  def number_at_level=(_arg0); end
912
1020
  end
913
1021
 
1022
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#77
914
1023
  class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
915
1024
  # @return [Boolean]
916
1025
  #
@@ -921,6 +1030,7 @@ class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
921
1030
  def parts; end
922
1031
  end
923
1032
 
1033
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#62
924
1034
  class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
925
1035
  # @return [Named] a new instance of Named
926
1036
  #
@@ -948,6 +1058,8 @@ end
948
1058
 
949
1059
  # TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no
950
1060
  # longer inherit from Group because it is effectively a terminal expression.
1061
+ #
1062
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#38
951
1063
  class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
952
1064
  # Returns the value of attribute option_changes.
953
1065
  #
@@ -970,6 +1082,7 @@ class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
970
1082
  def initialize_copy(orig); end
971
1083
  end
972
1084
 
1085
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#13
973
1086
  class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
974
1087
  # @return [Passive] a new instance of Passive
975
1088
  #
@@ -992,31 +1105,36 @@ class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
992
1105
  def parts; end
993
1106
  end
994
1107
 
1108
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#2
995
1109
  module Regexp::Expression::Keep; end
996
1110
 
997
1111
  # TOOD: in regexp_parser v3.0.0 this should possibly be a Subexpression
998
1112
  # that contains all expressions to its left.
1113
+ #
1114
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#5
999
1115
  class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
1000
1116
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#39
1001
1117
  def human_name; end
1002
1118
 
1003
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#144
1119
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
1004
1120
  def match_length; end
1005
1121
  end
1006
1122
 
1123
+ # source://regexp_parser//lib/regexp_parser/expression/classes/literal.rb#2
1007
1124
  class Regexp::Expression::Literal < ::Regexp::Expression::Base
1008
1125
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#40
1009
1126
  def human_name; end
1010
1127
 
1011
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#101
1128
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#105
1012
1129
  def match_length; end
1013
1130
  end
1014
1131
 
1015
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#81
1132
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#85
1016
1133
  Regexp::Expression::MatchLength = Regexp::MatchLength
1017
1134
 
1135
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2
1018
1136
  class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
1019
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
1137
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1020
1138
  def match_length; end
1021
1139
 
1022
1140
  # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#7
@@ -1032,6 +1150,8 @@ end
1032
1150
  # call super in #initialize, but raise in #quantifier= and #quantify,
1033
1151
  # or introduce an Expression::Quantifiable intermediate class.
1034
1152
  # Or actually allow chaining as a more concise but tricky solution than PR#69.
1153
+ #
1154
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#6
1035
1155
  class Regexp::Expression::Quantifier
1036
1156
  include ::Regexp::Expression::Shared
1037
1157
  extend ::Regexp::Expression::Shared::ClassMethods
@@ -1143,6 +1263,7 @@ end
1143
1263
  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#9
1144
1264
  Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
1145
1265
 
1266
+ # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#2
1146
1267
  class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
1147
1268
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#41
1148
1269
  def human_name; end
@@ -1159,14 +1280,16 @@ end
1159
1280
  #
1160
1281
  # Used as the base class for the Alternation alternatives, Conditional
1161
1282
  # branches, and CharacterSet::Intersection intersected sequences.
1283
+ #
1284
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8
1162
1285
  class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
1163
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#28
1286
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27
1164
1287
  def quantify(*args); end
1165
1288
 
1166
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1289
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22
1167
1290
  def starts_at; end
1168
1291
 
1169
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1292
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22
1170
1293
  def ts; end
1171
1294
 
1172
1295
  class << self
@@ -1176,6 +1299,8 @@ class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
1176
1299
  end
1177
1300
 
1178
1301
  # abstract class
1302
+ #
1303
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#3
1179
1304
  class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
1180
1305
  # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#13
1181
1306
  def <<(exp); end
@@ -1202,6 +1327,7 @@ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpressio
1202
1327
  def ts; end
1203
1328
  end
1204
1329
 
1330
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#2
1205
1331
  module Regexp::Expression::Shared
1206
1332
  mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
1207
1333
 
@@ -1257,7 +1383,7 @@ module Regexp::Expression::Shared
1257
1383
  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36
1258
1384
  def is?(test_token, test_type = T.unsafe(nil)); end
1259
1385
 
1260
- # source://regexp_parser//lib/regexp_parser/expression/shared.rb#83
1386
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#87
1261
1387
  def nesting_level=(lvl); end
1262
1388
 
1263
1389
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#71
@@ -1315,12 +1441,17 @@ module Regexp::Expression::Shared
1315
1441
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#63
1316
1442
  def quantified?; end
1317
1443
 
1318
- # source://regexp_parser//lib/regexp_parser/expression/shared.rb#89
1444
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#93
1319
1445
  def quantifier=(qtf); end
1320
1446
 
1321
1447
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#59
1322
1448
  def quantifier_affix(expression_format); end
1323
1449
 
1450
+ # @return [Boolean]
1451
+ #
1452
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#83
1453
+ def referential?; end
1454
+
1324
1455
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#38
1325
1456
  def starts_at; end
1326
1457
 
@@ -1369,6 +1500,8 @@ module Regexp::Expression::Shared
1369
1500
  end
1370
1501
 
1371
1502
  # filled in ./methods/*.rb
1503
+ #
1504
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#3
1372
1505
  module Regexp::Expression::Shared::ClassMethods
1373
1506
  # Convenience method to init a valid Expression without a Regexp::Token
1374
1507
  #
@@ -1384,6 +1517,7 @@ module Regexp::Expression::Shared::ClassMethods
1384
1517
  def token_class; end
1385
1518
  end
1386
1519
 
1520
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#2
1387
1521
  class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1388
1522
  include ::Enumerable
1389
1523
 
@@ -1395,25 +1529,25 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1395
1529
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#18
1396
1530
  def <<(exp); end
1397
1531
 
1398
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1532
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1399
1533
  def [](*args, &block); end
1400
1534
 
1401
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1535
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1402
1536
  def at(*args, &block); end
1403
1537
 
1404
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#35
1538
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#34
1405
1539
  def dig(*indices); end
1406
1540
 
1407
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1541
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1408
1542
  def each(*args, &block); end
1409
1543
 
1410
1544
  # Iterates over the expressions of this expression as an array, passing
1411
1545
  # the expression and its index within its parent to the given block.
1412
1546
  #
1413
1547
  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#39
1414
- def each_expression(include_self = T.unsafe(nil)); end
1548
+ def each_expression(include_self = T.unsafe(nil), &block); end
1415
1549
 
1416
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1550
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1417
1551
  def empty?(*args, &block); end
1418
1552
 
1419
1553
  # Returns the value of attribute expressions.
@@ -1428,35 +1562,35 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1428
1562
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1429
1563
  def expressions=(_arg0); end
1430
1564
 
1431
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1565
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1432
1566
  def fetch(*args, &block); end
1433
1567
 
1434
1568
  # Returns a new array with the results of calling the given block once
1435
1569
  # for every expression. If a block is not given, returns an array with
1436
1570
  # each expression and its level index as an array.
1437
1571
  #
1438
- # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#50
1572
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#53
1439
1573
  def flat_map(include_self = T.unsafe(nil)); end
1440
1574
 
1441
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1575
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1442
1576
  def index(*args, &block); end
1443
1577
 
1444
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#114
1578
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#118
1445
1579
  def inner_match_length; end
1446
1580
 
1447
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1581
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1448
1582
  def join(*args, &block); end
1449
1583
 
1450
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1584
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1451
1585
  def last(*args, &block); end
1452
1586
 
1453
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1587
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1454
1588
  def length(*args, &block); end
1455
1589
 
1456
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#107
1590
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#111
1457
1591
  def match_length; end
1458
1592
 
1459
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#45
1593
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#44
1460
1594
  def parts; end
1461
1595
 
1462
1596
  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
@@ -1465,10 +1599,15 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1465
1599
  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
1466
1600
  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
1467
1601
 
1468
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#41
1602
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#40
1469
1603
  def te; end
1470
1604
 
1471
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#49
1605
+ # @return [Boolean]
1606
+ #
1607
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#55
1608
+ def terminal?; end
1609
+
1610
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#48
1472
1611
  def to_h; end
1473
1612
 
1474
1613
  # Traverses the subexpression (depth-first, pre-order) and calls the given
@@ -1487,7 +1626,7 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1487
1626
  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#16
1488
1627
  def traverse(include_self = T.unsafe(nil), &block); end
1489
1628
 
1490
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1629
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1491
1630
  def values_at(*args, &block); end
1492
1631
 
1493
1632
  # Traverses the subexpression (depth-first, pre-order) and calls the given
@@ -1513,22 +1652,36 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1513
1652
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13
1514
1653
  def initialize_copy(orig); end
1515
1654
 
1516
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#58
1655
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#61
1517
1656
  def intersperse(expressions, separator); end
1518
1657
  end
1519
1658
 
1520
1659
  # TODO: unify name with token :property, one way or the other, in v3.0.0
1660
+ #
1661
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3
1521
1662
  module Regexp::Expression::UnicodeProperty; end
1522
1663
 
1664
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113
1523
1665
  class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
1666
+
1667
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18
1524
1668
  class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
1669
+
1670
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19
1525
1671
  class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
1672
+
1673
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#36
1526
1674
  class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
1675
+
1676
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20
1527
1677
  class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
1678
+
1679
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#37
1528
1680
  class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
1529
1681
 
1682
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4
1530
1683
  class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
1531
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#94
1684
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1532
1685
  def match_length; end
1533
1686
 
1534
1687
  # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#9
@@ -1543,77 +1696,217 @@ class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
1543
1696
  def shortcut; end
1544
1697
  end
1545
1698
 
1699
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21
1546
1700
  class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
1701
+
1702
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#117
1547
1703
  class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
1704
+
1705
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22
1548
1706
  class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
1707
+
1708
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102
1549
1709
  module Regexp::Expression::UnicodeProperty::Codepoint; end
1710
+
1711
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105
1550
1712
  class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1713
+
1714
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#103
1551
1715
  class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1716
+
1717
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#106
1552
1718
  class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1719
+
1720
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#107
1553
1721
  class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1722
+
1723
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109
1554
1724
  class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1725
+
1726
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108
1555
1727
  class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1728
+
1729
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#110
1556
1730
  class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1731
+
1732
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#114
1557
1733
  class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
1734
+
1735
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23
1558
1736
  class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
1737
+
1738
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#115
1559
1739
  class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
1740
+
1741
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24
1560
1742
  class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
1743
+
1744
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39
1561
1745
  module Regexp::Expression::UnicodeProperty::Letter; end
1746
+
1747
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42
1562
1748
  class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1749
+
1750
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#40
1563
1751
  class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1752
+
1753
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43
1564
1754
  class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1755
+
1756
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#45
1565
1757
  class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1758
+
1759
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47
1566
1760
  class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1761
+
1762
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#48
1567
1763
  class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1764
+
1765
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46
1568
1766
  class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1767
+
1768
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#44
1569
1769
  class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1770
+
1771
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25
1570
1772
  class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
1773
+
1774
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51
1571
1775
  module Regexp::Expression::UnicodeProperty::Mark; end
1776
+
1777
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#54
1572
1778
  class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1779
+
1780
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#52
1573
1781
  class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1782
+
1783
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#55
1574
1784
  class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1785
+
1786
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#58
1575
1787
  class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1788
+
1789
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56
1576
1790
  class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1791
+
1792
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57
1577
1793
  class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1794
+
1795
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#34
1578
1796
  class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
1797
+
1798
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61
1579
1799
  module Regexp::Expression::UnicodeProperty::Number; end
1800
+
1801
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#64
1580
1802
  class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1803
+
1804
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#62
1581
1805
  class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1806
+
1807
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65
1582
1808
  class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1809
+
1810
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66
1583
1811
  class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1812
+
1813
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#67
1584
1814
  class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1815
+
1816
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26
1585
1817
  class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
1818
+
1819
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27
1586
1820
  class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
1821
+
1822
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70
1587
1823
  module Regexp::Expression::UnicodeProperty::Punctuation; end
1824
+
1825
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73
1588
1826
  class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1827
+
1828
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#71
1589
1829
  class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1830
+
1831
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#77
1590
1832
  class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1833
+
1834
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74
1591
1835
  class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1836
+
1837
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75
1592
1838
  class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1839
+
1840
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79
1593
1841
  class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1842
+
1843
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78
1594
1844
  class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1845
+
1846
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#76
1595
1847
  class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1848
+
1849
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#80
1596
1850
  class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
1851
+
1852
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#116
1597
1853
  class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
1854
+
1855
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83
1598
1856
  module Regexp::Expression::UnicodeProperty::Separator; end
1857
+
1858
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#86
1599
1859
  class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1860
+
1861
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#84
1600
1862
  class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1863
+
1864
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88
1601
1865
  class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1866
+
1867
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#89
1602
1868
  class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1869
+
1870
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87
1603
1871
  class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
1872
+
1873
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#28
1604
1874
  class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
1875
+
1876
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92
1605
1877
  module Regexp::Expression::UnicodeProperty::Symbol; end
1878
+
1879
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#95
1606
1880
  class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1881
+
1882
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#93
1607
1883
  class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1884
+
1885
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97
1608
1886
  class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1887
+
1888
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#96
1609
1889
  class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1890
+
1891
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98
1610
1892
  class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1893
+
1894
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#99
1611
1895
  class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
1896
+
1897
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29
1612
1898
  class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
1899
+
1900
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#30
1613
1901
  class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
1902
+
1903
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#32
1614
1904
  class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
1905
+
1906
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31
1615
1907
  class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
1616
1908
 
1909
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#10
1617
1910
  class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
1618
1911
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#42
1619
1912
  def human_name; end
@@ -1626,96 +1919,153 @@ end
1626
1919
  # collects emitted tokens into an array, calculates their nesting depth, and
1627
1920
  # normalizes tokens for the parser, and checks if they are implemented by the
1628
1921
  # given syntax flavor.
1922
+ #
1923
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#5
1629
1924
  class Regexp::Lexer
1925
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#71
1926
+ def emit(token); end
1927
+
1630
1928
  # source://regexp_parser//lib/regexp_parser/lexer.rb#20
1631
- def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
1929
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
1632
1930
 
1633
1931
  private
1634
1932
 
1635
- # source://regexp_parser//lib/regexp_parser/lexer.rb#71
1933
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#91
1636
1934
  def ascend(type, token); end
1637
1935
 
1638
- # source://regexp_parser//lib/regexp_parser/lexer.rb#108
1936
+ # Returns the value of attribute block.
1937
+ #
1938
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1939
+ def block; end
1940
+
1941
+ # Sets the attribute block
1942
+ #
1943
+ # @param value the value to set the attribute block to.
1944
+ #
1945
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1946
+ def block=(_arg0); end
1947
+
1948
+ # if a codepoint list is followed by a quantifier, that quantifier applies
1949
+ # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc'
1950
+ # c.f. #break_literal.
1951
+ #
1952
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#135
1639
1953
  def break_codepoint_list(token); end
1640
1954
 
1641
1955
  # called by scan to break a literal run that is longer than one character
1642
1956
  # into two separate tokens when it is followed by a quantifier
1643
1957
  #
1644
- # source://regexp_parser//lib/regexp_parser/lexer.rb#95
1958
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#115
1645
1959
  def break_literal(token); end
1646
1960
 
1961
+ # Returns the value of attribute collect_tokens.
1962
+ #
1963
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1964
+ def collect_tokens; end
1965
+
1966
+ # Sets the attribute collect_tokens
1967
+ #
1968
+ # @param value the value to set the attribute collect_tokens to.
1969
+ #
1970
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1971
+ def collect_tokens=(_arg0); end
1972
+
1647
1973
  # Returns the value of attribute conditional_nesting.
1648
1974
  #
1649
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1975
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1650
1976
  def conditional_nesting; end
1651
1977
 
1652
1978
  # Sets the attribute conditional_nesting
1653
1979
  #
1654
1980
  # @param value the value to set the attribute conditional_nesting to.
1655
1981
  #
1656
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1982
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1657
1983
  def conditional_nesting=(_arg0); end
1658
1984
 
1659
- # source://regexp_parser//lib/regexp_parser/lexer.rb#82
1985
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#102
1660
1986
  def descend(type, token); end
1661
1987
 
1662
- # source://regexp_parser//lib/regexp_parser/lexer.rb#123
1663
- def merge_condition(current); end
1988
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#154
1989
+ def merge_condition(current, last); end
1664
1990
 
1665
1991
  # Returns the value of attribute nesting.
1666
1992
  #
1667
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1993
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1668
1994
  def nesting; end
1669
1995
 
1670
1996
  # Sets the attribute nesting
1671
1997
  #
1672
1998
  # @param value the value to set the attribute nesting to.
1673
1999
  #
1674
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2000
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1675
2001
  def nesting=(_arg0); end
1676
2002
 
2003
+ # Returns the value of attribute preprev_token.
2004
+ #
2005
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2006
+ def preprev_token; end
2007
+
2008
+ # Sets the attribute preprev_token
2009
+ #
2010
+ # @param value the value to set the attribute preprev_token to.
2011
+ #
2012
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2013
+ def preprev_token=(_arg0); end
2014
+
2015
+ # Returns the value of attribute prev_token.
2016
+ #
2017
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2018
+ def prev_token; end
2019
+
2020
+ # Sets the attribute prev_token
2021
+ #
2022
+ # @param value the value to set the attribute prev_token to.
2023
+ #
2024
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2025
+ def prev_token=(_arg0); end
2026
+
1677
2027
  # Returns the value of attribute set_nesting.
1678
2028
  #
1679
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2029
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1680
2030
  def set_nesting; end
1681
2031
 
1682
2032
  # Sets the attribute set_nesting
1683
2033
  #
1684
2034
  # @param value the value to set the attribute set_nesting to.
1685
2035
  #
1686
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2036
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1687
2037
  def set_nesting=(_arg0); end
1688
2038
 
1689
2039
  # Returns the value of attribute shift.
1690
2040
  #
1691
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2041
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1692
2042
  def shift; end
1693
2043
 
1694
2044
  # Sets the attribute shift
1695
2045
  #
1696
2046
  # @param value the value to set the attribute shift to.
1697
2047
  #
1698
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2048
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1699
2049
  def shift=(_arg0); end
1700
2050
 
1701
2051
  # Returns the value of attribute tokens.
1702
2052
  #
1703
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2053
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1704
2054
  def tokens; end
1705
2055
 
1706
2056
  # Sets the attribute tokens
1707
2057
  #
1708
2058
  # @param value the value to set the attribute tokens to.
1709
2059
  #
1710
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2060
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1711
2061
  def tokens=(_arg0); end
1712
2062
 
1713
2063
  class << self
1714
2064
  # source://regexp_parser//lib/regexp_parser/lexer.rb#16
1715
- def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2065
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
1716
2066
 
1717
2067
  # source://regexp_parser//lib/regexp_parser/lexer.rb#16
1718
- def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2068
+ def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
1719
2069
  end
1720
2070
  end
1721
2071
 
@@ -1728,6 +2078,7 @@ Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array)
1728
2078
  # source://regexp_parser//lib/regexp_parser/lexer.rb#7
1729
2079
  Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
1730
2080
 
2081
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#1
1731
2082
  class Regexp::MatchLength
1732
2083
  include ::Enumerable
1733
2084
 
@@ -1841,7 +2192,7 @@ class Regexp::MatchLength
1841
2192
  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
1842
2193
  def reify=(_arg0); end
1843
2194
 
1844
- # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#73
2195
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#74
1845
2196
  def test_regexp; end
1846
2197
 
1847
2198
  class << self
@@ -1850,6 +2201,7 @@ class Regexp::MatchLength
1850
2201
  end
1851
2202
  end
1852
2203
 
2204
+ # source://regexp_parser//lib/regexp_parser/version.rb#2
1853
2205
  class Regexp::Parser
1854
2206
  include ::Regexp::Expression
1855
2207
  include ::Regexp::Expression::UnicodeProperty
@@ -2067,16 +2419,20 @@ end
2067
2419
  Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
2068
2420
 
2069
2421
  # base class for all gem-specific errors
2422
+ #
2423
+ # source://regexp_parser//lib/regexp_parser/error.rb#3
2070
2424
  class Regexp::Parser::Error < ::StandardError; end
2071
2425
 
2072
2426
  # source://regexp_parser//lib/regexp_parser/parser.rb#127
2073
2427
  Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
2074
2428
 
2429
+ # source://regexp_parser//lib/regexp_parser/parser.rb#7
2075
2430
  class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
2076
2431
 
2077
2432
  # source://regexp_parser//lib/regexp_parser/parser.rb#397
2078
2433
  Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
2079
2434
 
2435
+ # source://regexp_parser//lib/regexp_parser/parser.rb#15
2080
2436
  class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
2081
2437
  # @return [UnknownTokenError] a new instance of UnknownTokenError
2082
2438
  #
@@ -2084,6 +2440,7 @@ class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
2084
2440
  def initialize(type, token); end
2085
2441
  end
2086
2442
 
2443
+ # source://regexp_parser//lib/regexp_parser/parser.rb#9
2087
2444
  class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
2088
2445
  # @return [UnknownTokenTypeError] a new instance of UnknownTokenTypeError
2089
2446
  #
@@ -2094,178 +2451,201 @@ end
2094
2451
  # source://regexp_parser//lib/regexp_parser/version.rb#3
2095
2452
  Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
2096
2453
 
2454
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#13
2097
2455
  class Regexp::Scanner
2098
2456
  # Emits an array with the details of the scanned pattern
2099
2457
  #
2100
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2555
2458
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2591
2101
2459
  def emit(type, token, text); end
2102
2460
 
2461
+ # only public for #||= to work on ruby <= 2.5
2462
+ #
2463
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2616
2464
+ def literal_run; end
2465
+
2466
+ # only public for #||= to work on ruby <= 2.5
2467
+ #
2468
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2616
2469
+ def literal_run=(_arg0); end
2470
+
2103
2471
  # @raise [PrematureEndError]
2104
2472
  #
2105
2473
  # source://regexp_parser//lib/regexp_parser/scanner.rb#84
2106
- def scan(input_object, options: T.unsafe(nil), &block); end
2474
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2107
2475
 
2108
2476
  private
2109
2477
 
2110
2478
  # Appends one or more characters to the literal buffer, to be emitted later
2111
2479
  # by a call to emit_literal.
2112
2480
  #
2113
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2606
2481
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2653
2114
2482
  def append_literal(data, ts, te); end
2115
2483
 
2116
2484
  # Returns the value of attribute block.
2117
2485
  #
2118
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2486
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2119
2487
  def block; end
2120
2488
 
2121
2489
  # Sets the attribute block
2122
2490
  #
2123
2491
  # @param value the value to set the attribute block to.
2124
2492
  #
2125
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2493
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2126
2494
  def block=(_arg0); end
2127
2495
 
2128
2496
  # Returns the value of attribute char_pos.
2129
2497
  #
2130
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2498
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2131
2499
  def char_pos; end
2132
2500
 
2133
2501
  # Sets the attribute char_pos
2134
2502
  #
2135
2503
  # @param value the value to set the attribute char_pos to.
2136
2504
  #
2137
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2505
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2138
2506
  def char_pos=(_arg0); end
2139
2507
 
2508
+ # Returns the value of attribute collect_tokens.
2509
+ #
2510
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2511
+ def collect_tokens; end
2512
+
2513
+ # Sets the attribute collect_tokens
2514
+ #
2515
+ # @param value the value to set the attribute collect_tokens to.
2516
+ #
2517
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2518
+ def collect_tokens=(_arg0); end
2519
+
2140
2520
  # Returns the value of attribute conditional_stack.
2141
2521
  #
2142
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2522
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2143
2523
  def conditional_stack; end
2144
2524
 
2145
2525
  # Sets the attribute conditional_stack
2146
2526
  #
2147
2527
  # @param value the value to set the attribute conditional_stack to.
2148
2528
  #
2149
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2529
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2150
2530
  def conditional_stack=(_arg0); end
2151
2531
 
2152
2532
  # Copy from ts to te from data as text
2153
2533
  #
2154
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2600
2534
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2647
2155
2535
  def copy(data, ts, te); end
2156
2536
 
2157
2537
  # Emits the literal run collected by calls to the append_literal method.
2158
2538
  #
2159
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2612
2539
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2658
2160
2540
  def emit_literal; end
2161
2541
 
2162
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2647
2542
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2693
2163
2543
  def emit_meta_control_sequence(data, ts, te, token); end
2164
2544
 
2165
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2618
2545
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2664
2166
2546
  def emit_options(text); end
2167
2547
 
2168
2548
  # Returns the value of attribute free_spacing.
2169
2549
  #
2170
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2550
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2171
2551
  def free_spacing; end
2172
2552
 
2173
2553
  # Sets the attribute free_spacing
2174
2554
  #
2175
2555
  # @param value the value to set the attribute free_spacing to.
2176
2556
  #
2177
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2557
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2178
2558
  def free_spacing=(_arg0); end
2179
2559
 
2180
2560
  # @return [Boolean]
2181
2561
  #
2182
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2579
2562
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2626
2183
2563
  def free_spacing?(input_object, options); end
2184
2564
 
2185
2565
  # Returns the value of attribute group_depth.
2186
2566
  #
2187
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2567
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2188
2568
  def group_depth; end
2189
2569
 
2190
2570
  # Sets the attribute group_depth
2191
2571
  #
2192
2572
  # @param value the value to set the attribute group_depth to.
2193
2573
  #
2194
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2574
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2195
2575
  def group_depth=(_arg0); end
2196
2576
 
2197
2577
  # @return [Boolean]
2198
2578
  #
2199
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2591
2579
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2638
2200
2580
  def in_group?; end
2201
2581
 
2202
2582
  # @return [Boolean]
2203
2583
  #
2204
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2595
2584
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2642
2205
2585
  def in_set?; end
2206
2586
 
2207
- # Returns the value of attribute literal.
2587
+ # Returns the value of attribute prev_token.
2208
2588
  #
2209
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2210
- def literal; end
2589
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2590
+ def prev_token; end
2211
2591
 
2212
- # Sets the attribute literal
2592
+ # Sets the attribute prev_token
2213
2593
  #
2214
- # @param value the value to set the attribute literal to.
2594
+ # @param value the value to set the attribute prev_token to.
2215
2595
  #
2216
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2217
- def literal=(_arg0); end
2596
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2597
+ def prev_token=(_arg0); end
2218
2598
 
2219
2599
  # Returns the value of attribute set_depth.
2220
2600
  #
2221
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2601
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2222
2602
  def set_depth; end
2223
2603
 
2224
2604
  # Sets the attribute set_depth
2225
2605
  #
2226
2606
  # @param value the value to set the attribute set_depth to.
2227
2607
  #
2228
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2608
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2229
2609
  def set_depth=(_arg0); end
2230
2610
 
2231
2611
  # Returns the value of attribute spacing_stack.
2232
2612
  #
2233
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2613
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2234
2614
  def spacing_stack; end
2235
2615
 
2236
2616
  # Sets the attribute spacing_stack
2237
2617
  #
2238
2618
  # @param value the value to set the attribute spacing_stack to.
2239
2619
  #
2240
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2620
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2241
2621
  def spacing_stack=(_arg0); end
2242
2622
 
2243
2623
  # Returns the value of attribute tokens.
2244
2624
  #
2245
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2625
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2246
2626
  def tokens; end
2247
2627
 
2248
2628
  # Sets the attribute tokens
2249
2629
  #
2250
2630
  # @param value the value to set the attribute tokens to.
2251
2631
  #
2252
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2632
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2253
2633
  def tokens=(_arg0); end
2254
2634
 
2255
2635
  # Centralizes and unifies the handling of validation related
2256
2636
  # errors.
2257
2637
  #
2258
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2656
2638
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2702
2259
2639
  def validation_error(type, what, reason = T.unsafe(nil)); end
2260
2640
 
2261
2641
  class << self
2262
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2541
2642
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2577
2263
2643
  def long_prop_map; end
2264
2644
 
2265
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2545
2645
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2581
2266
2646
  def parse_prop_map(name); end
2267
2647
 
2268
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2549
2648
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2585
2269
2649
  def posix_classes; end
2270
2650
 
2271
2651
  # Scans the given regular expression text, or Regexp object and collects the
@@ -2276,16 +2656,18 @@ class Regexp::Scanner
2276
2656
  # --------------------------------------------------------------------------
2277
2657
  #
2278
2658
  # source://regexp_parser//lib/regexp_parser/scanner.rb#80
2279
- def scan(input_object, options: T.unsafe(nil), &block); end
2659
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2280
2660
 
2281
2661
  # lazy-load property maps when first needed
2282
2662
  #
2283
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2537
2663
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2573
2284
2664
  def short_prop_map; end
2285
2665
  end
2286
2666
  end
2287
2667
 
2288
2668
  # Invalid back reference. Used for name a number refs/calls.
2669
+ #
2670
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#54
2289
2671
  class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
2290
2672
  # @return [InvalidBackrefError] a new instance of InvalidBackrefError
2291
2673
  #
@@ -2294,6 +2676,8 @@ class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
2294
2676
  end
2295
2677
 
2296
2678
  # Invalid group. Used for named groups.
2679
+ #
2680
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#39
2297
2681
  class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
2298
2682
  # @return [InvalidGroupError] a new instance of InvalidGroupError
2299
2683
  #
@@ -2303,6 +2687,8 @@ end
2303
2687
 
2304
2688
  # Invalid groupOption. Used for inline options.
2305
2689
  # TODO: should become InvalidGroupOptionError in v3.0.0 for consistency
2690
+ #
2691
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#47
2306
2692
  class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
2307
2693
  # @return [InvalidGroupOption] a new instance of InvalidGroupOption
2308
2694
  #
@@ -2311,6 +2697,8 @@ class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
2311
2697
  end
2312
2698
 
2313
2699
  # Invalid sequence format. Used for escape sequences, mainly.
2700
+ #
2701
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#32
2314
2702
  class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
2315
2703
  # @return [InvalidSequenceError] a new instance of InvalidSequenceError
2316
2704
  #
@@ -2319,6 +2707,8 @@ class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
2319
2707
  end
2320
2708
 
2321
2709
  # Unexpected end of pattern
2710
+ #
2711
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#25
2322
2712
  class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
2323
2713
  # @return [PrematureEndError] a new instance of PrematureEndError
2324
2714
  #
@@ -2327,9 +2717,13 @@ class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
2327
2717
  end
2328
2718
 
2329
2719
  # General scanner error (catch all)
2720
+ #
2721
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#15
2330
2722
  class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
2331
2723
 
2332
2724
  # The POSIX class name was not recognized by the scanner.
2725
+ #
2726
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#68
2333
2727
  class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
2334
2728
  # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError
2335
2729
  #
@@ -2338,6 +2732,8 @@ class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationErr
2338
2732
  end
2339
2733
 
2340
2734
  # The property name was not recognized by the scanner.
2735
+ #
2736
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#61
2341
2737
  class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
2342
2738
  # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError
2343
2739
  #
@@ -2346,6 +2742,8 @@ class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::Validati
2346
2742
  end
2347
2743
 
2348
2744
  # Base for all scanner validation errors
2745
+ #
2746
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#18
2349
2747
  class Regexp::Scanner::ValidationError < ::Regexp::Parser::Error
2350
2748
  # @return [ValidationError] a new instance of ValidationError
2351
2749
  #
@@ -2355,16 +2753,18 @@ end
2355
2753
 
2356
2754
  # After loading all the tokens the map is full. Extract all tokens and types
2357
2755
  # into the All and Types constants.
2756
+ #
2757
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#3
2358
2758
  module Regexp::Syntax
2359
2759
  private
2360
2760
 
2361
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#62
2761
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2362
2762
  def comparable(name); end
2363
2763
 
2364
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#45
2764
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2365
2765
  def const_missing(const_name); end
2366
2766
 
2367
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#52
2767
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2368
2768
  def fallback_version_class(version); end
2369
2769
 
2370
2770
  # Returns the syntax specification class for the given syntax
@@ -2376,7 +2776,7 @@ module Regexp::Syntax
2376
2776
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2377
2777
  def new(name); end
2378
2778
 
2379
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#58
2779
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2380
2780
  def specified_versions; end
2381
2781
 
2382
2782
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
@@ -2385,17 +2785,14 @@ module Regexp::Syntax
2385
2785
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2386
2786
  def version_class(version); end
2387
2787
 
2388
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#67
2389
- def warn_if_future_version(const_name); end
2390
-
2391
2788
  class << self
2392
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#62
2789
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2393
2790
  def comparable(name); end
2394
2791
 
2395
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#45
2792
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2396
2793
  def const_missing(const_name); end
2397
2794
 
2398
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#52
2795
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2399
2796
  def fallback_version_class(version); end
2400
2797
 
2401
2798
  # Returns the syntax specification class for the given syntax
@@ -2407,7 +2804,7 @@ module Regexp::Syntax
2407
2804
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2408
2805
  def new(name); end
2409
2806
 
2410
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#58
2807
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2411
2808
  def specified_versions; end
2412
2809
 
2413
2810
  # @return [Boolean]
@@ -2417,15 +2814,14 @@ module Regexp::Syntax
2417
2814
 
2418
2815
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2419
2816
  def version_class(version); end
2420
-
2421
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#67
2422
- def warn_if_future_version(const_name); end
2423
2817
  end
2424
2818
  end
2425
2819
 
2426
2820
  # A syntax that always returns true, passing all tokens as implemented. This
2427
2821
  # is useful during development, testing, and should be useful for some types
2428
2822
  # of transformations as well.
2823
+ #
2824
+ # source://regexp_parser//lib/regexp_parser/syntax/any.rb#5
2429
2825
  class Regexp::Syntax::Any < ::Regexp::Syntax::Base
2430
2826
  class << self
2431
2827
  # @return [Boolean]
@@ -2436,6 +2832,8 @@ class Regexp::Syntax::Any < ::Regexp::Syntax::Base
2436
2832
  end
2437
2833
 
2438
2834
  # A lookup map of supported types and tokens in a given syntax
2835
+ #
2836
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#9
2439
2837
  class Regexp::Syntax::Base
2440
2838
  include ::Regexp::Syntax::Token
2441
2839
 
@@ -2520,6 +2918,10 @@ class Regexp::Syntax::Base
2520
2918
  end
2521
2919
  end
2522
2920
 
2921
+ # source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8
2922
+ Regexp::Syntax::CURRENT = Regexp::Syntax::V3_2_0
2923
+
2924
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6
2523
2925
  class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
2524
2926
  # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError
2525
2927
  #
@@ -2527,6 +2929,7 @@ class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
2527
2929
  def initialize(name); end
2528
2930
  end
2529
2931
 
2932
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#2
2530
2933
  class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
2531
2934
  # @return [NotImplementedError] a new instance of NotImplementedError
2532
2935
  #
@@ -2534,12 +2937,16 @@ class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
2534
2937
  def initialize(syntax, type, token); end
2535
2938
  end
2536
2939
 
2940
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#4
2537
2941
  class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
2942
+
2943
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#3
2538
2944
  module Regexp::Syntax::Token; end
2539
2945
 
2540
2946
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#42
2541
2947
  Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
2542
2948
 
2949
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#3
2543
2950
  module Regexp::Syntax::Token::Anchor; end
2544
2951
 
2545
2952
  # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#9
@@ -2560,6 +2967,7 @@ Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
2560
2967
  # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#10
2561
2968
  Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
2562
2969
 
2970
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#3
2563
2971
  module Regexp::Syntax::Token::Assertion; end
2564
2972
 
2565
2973
  # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#7
@@ -2574,6 +2982,7 @@ Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
2574
2982
  # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#8
2575
2983
  Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
2576
2984
 
2985
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#3
2577
2986
  module Regexp::Syntax::Token::Backreference; end
2578
2987
 
2579
2988
  # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#15
@@ -2603,6 +3012,7 @@ Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array)
2603
3012
  # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#13
2604
3013
  Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array)
2605
3014
 
3015
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#3
2606
3016
  module Regexp::Syntax::Token::CharacterSet; end
2607
3017
 
2608
3018
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#7
@@ -2617,6 +3027,7 @@ Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
2617
3027
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#8
2618
3028
  Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
2619
3029
 
3030
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#3
2620
3031
  module Regexp::Syntax::Token::CharacterType; end
2621
3032
 
2622
3033
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#10
@@ -2637,6 +3048,7 @@ Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
2637
3048
  # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#11
2638
3049
  Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
2639
3050
 
3051
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#3
2640
3052
  module Regexp::Syntax::Token::Conditional; end
2641
3053
 
2642
3054
  # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#9
@@ -2655,6 +3067,8 @@ Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
2655
3067
  Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
2656
3068
 
2657
3069
  # TODO: unify naming with RE::EscapeSequence, one way or the other, in v3.0.0
3070
+ #
3071
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4
2658
3072
  module Regexp::Syntax::Token::Escape; end
2659
3073
 
2660
3074
  # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#9
@@ -2684,6 +3098,7 @@ Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
2684
3098
  # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#12
2685
3099
  Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
2686
3100
 
3101
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#11
2687
3102
  module Regexp::Syntax::Token::FreeSpace; end
2688
3103
 
2689
3104
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#12
@@ -2692,6 +3107,7 @@ Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
2692
3107
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#13
2693
3108
  Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
2694
3109
 
3110
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#3
2695
3111
  module Regexp::Syntax::Token::Group; end
2696
3112
 
2697
3113
  # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#17
@@ -2724,6 +3140,7 @@ Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
2724
3140
  # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#15
2725
3141
  Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
2726
3142
 
3143
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#3
2727
3144
  module Regexp::Syntax::Token::Keep; end
2728
3145
 
2729
3146
  # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#6
@@ -2735,6 +3152,7 @@ Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
2735
3152
  # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#7
2736
3153
  Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
2737
3154
 
3155
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#6
2738
3156
  module Regexp::Syntax::Token::Literal; end
2739
3157
 
2740
3158
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#7
@@ -2746,6 +3164,7 @@ Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
2746
3164
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#4
2747
3165
  Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
2748
3166
 
3167
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#3
2749
3168
  module Regexp::Syntax::Token::Meta; end
2750
3169
 
2751
3170
  # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#7
@@ -2760,6 +3179,7 @@ Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
2760
3179
  # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8
2761
3180
  Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
2762
3181
 
3182
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#3
2763
3183
  module Regexp::Syntax::Token::PosixClass; end
2764
3184
 
2765
3185
  # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#9
@@ -2777,6 +3197,7 @@ Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
2777
3197
  # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#10
2778
3198
  Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
2779
3199
 
3200
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#3
2780
3201
  module Regexp::Syntax::Token::Quantifier; end
2781
3202
 
2782
3203
  # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#29
@@ -2810,6 +3231,8 @@ Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
2810
3231
  Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array)
2811
3232
 
2812
3233
  # Type is the same as Backreference so keeping it here, for now.
3234
+ #
3235
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#20
2813
3236
  module Regexp::Syntax::Token::SubexpressionCall; end
2814
3237
 
2815
3238
  # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#24
@@ -2824,6 +3247,7 @@ Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
2824
3247
  # source://regexp_parser//lib/regexp_parser/syntax/token.rb#43
2825
3248
  Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
2826
3249
 
3250
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#3
2827
3251
  module Regexp::Syntax::Token::UnicodeProperty; end
2828
3252
 
2829
3253
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#64
@@ -2865,6 +3289,7 @@ Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array)
2865
3289
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#708
2866
3290
  Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
2867
3291
 
3292
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#13
2868
3293
  module Regexp::Syntax::Token::UnicodeProperty::Category; end
2869
3294
 
2870
3295
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#36
@@ -3032,6 +3457,7 @@ Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array)
3032
3457
  # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706
3033
3458
  Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array)
3034
3459
 
3460
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#12
3035
3461
  class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
3036
3462
  # @return [UnknownSyntaxNameError] a new instance of UnknownSyntaxNameError
3037
3463
  #
@@ -3039,19 +3465,46 @@ class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
3039
3465
  def initialize(name); end
3040
3466
  end
3041
3467
 
3468
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.8.6.rb#1
3042
3469
  class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end
3470
+
3471
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.1.rb#1
3043
3472
  class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end
3473
+
3474
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.3.rb#1
3044
3475
  class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end
3476
+
3477
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.0.0.rb#1
3045
3478
  class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end
3479
+
3480
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.2.0.rb#1
3046
3481
  class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end
3482
+
3483
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.3.0.rb#1
3047
3484
  class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end
3485
+
3486
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.0.rb#1
3048
3487
  class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end
3488
+
3489
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.1.rb#1
3049
3490
  class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end
3491
+
3492
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.5.0.rb#1
3050
3493
  class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end
3494
+
3495
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.0.rb#1
3051
3496
  class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end
3497
+
3498
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.2.rb#1
3052
3499
  class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end
3500
+
3501
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.3.rb#1
3053
3502
  class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end
3503
+
3504
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.1.0.rb#1
3054
3505
  class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end
3506
+
3507
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.2.0.rb#1
3055
3508
  class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end
3056
3509
 
3057
3510
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#4
@@ -3066,6 +3519,7 @@ Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
3066
3519
  # source://regexp_parser//lib/regexp_parser/token.rb#2
3067
3520
  Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
3068
3521
 
3522
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3069
3523
  class Regexp::Token < ::Struct
3070
3524
  def conditional_level; end
3071
3525
  def conditional_level=(_); end