ruby-paseto 0.1.0 → 0.1.2

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.
@@ -15,7 +15,7 @@ class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
15
15
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#9
16
16
  def human_name; end
17
17
 
18
- # 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
19
19
  def match_length; end
20
20
  end
21
21
 
@@ -41,7 +41,7 @@ Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
41
41
 
42
42
  # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#3
43
43
  class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
44
- # 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
45
45
  def match_length; end
46
46
  end
47
47
 
@@ -107,7 +107,7 @@ module Regexp::Expression::Assertion; end
107
107
 
108
108
  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#87
109
109
  class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
110
- # 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
111
111
  def match_length; end
112
112
  end
113
113
 
@@ -142,7 +142,7 @@ module Regexp::Expression::Backreference; end
142
142
 
143
143
  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4
144
144
  class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
145
- # 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
146
146
  def match_length; end
147
147
 
148
148
  # Returns the value of attribute referenced_expression.
@@ -157,17 +157,22 @@ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
157
157
  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#5
158
158
  def referenced_expression=(_arg0); end
159
159
 
160
+ # @return [Boolean]
161
+ #
162
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
163
+ def referential?; end
164
+
160
165
  private
161
166
 
162
167
  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#7
163
168
  def initialize_copy(orig); end
164
169
  end
165
170
 
166
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#23
171
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#39
167
172
  class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
168
173
  # @return [Name] a new instance of Name
169
174
  #
170
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#27
175
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43
171
176
  def initialize(token, options = T.unsafe(nil)); end
172
177
 
173
178
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23
@@ -175,39 +180,39 @@ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backrefere
175
180
 
176
181
  # Returns the value of attribute name.
177
182
  #
178
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
183
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40
179
184
  def name; end
180
185
 
181
186
  # Returns the value of attribute name.
182
187
  #
183
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
188
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40
184
189
  def reference; end
185
190
  end
186
191
 
187
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#39
192
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#55
188
193
  class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
189
194
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24
190
195
  def human_name; end
191
196
  end
192
197
 
193
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#51
198
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#67
194
199
  class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
195
200
  # @return [NameRecursionLevel] a new instance of NameRecursionLevel
196
201
  #
197
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
202
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#70
198
203
  def initialize(token, options = T.unsafe(nil)); end
199
204
 
200
205
  # Returns the value of attribute recursion_level.
201
206
  #
202
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#52
207
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#68
203
208
  def recursion_level; end
204
209
  end
205
210
 
206
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#13
211
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#29
207
212
  class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
208
213
  # @return [Number] a new instance of Number
209
214
  #
210
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#17
215
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#33
211
216
  def initialize(token, options = T.unsafe(nil)); end
212
217
 
213
218
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25
@@ -215,52 +220,52 @@ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backrefe
215
220
 
216
221
  # Returns the value of attribute number.
217
222
  #
218
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#14
223
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30
219
224
  def number; end
220
225
 
221
226
  # Returns the value of attribute number.
222
227
  #
223
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#14
228
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30
224
229
  def reference; end
225
230
  end
226
231
 
227
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#38
232
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
228
233
  class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
229
234
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27
230
235
  def human_name; end
231
236
  end
232
237
 
233
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#40
238
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56
234
239
  class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
235
240
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28
236
241
  def human_name; end
237
242
  end
238
243
 
239
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#42
244
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#58
240
245
  class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative
241
246
  # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel
242
247
  #
243
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
248
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#61
244
249
  def initialize(token, options = T.unsafe(nil)); end
245
250
 
246
251
  # Returns the value of attribute recursion_level.
247
252
  #
248
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43
253
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#59
249
254
  def recursion_level; end
250
255
  end
251
256
 
252
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#33
257
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49
253
258
  class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
254
259
  # Returns the value of attribute effective_number.
255
260
  #
256
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
261
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
257
262
  def effective_number; end
258
263
 
259
264
  # Sets the attribute effective_number
260
265
  #
261
266
  # @param value the value to set the attribute effective_number to.
262
267
  #
263
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
268
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
264
269
  def effective_number=(_arg0); end
265
270
 
266
271
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26
@@ -268,7 +273,7 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::
268
273
 
269
274
  # Returns the value of attribute effective_number.
270
275
  #
271
- # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
276
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
272
277
  def reference; end
273
278
  end
274
279
 
@@ -576,7 +581,7 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
576
581
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
577
582
  def closed?; end
578
583
 
579
- # 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
580
585
  def match_length; end
581
586
 
582
587
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#15
@@ -613,7 +618,7 @@ class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expressi
613
618
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#29
614
619
  def human_name; end
615
620
 
616
- # 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
617
622
  def match_length; end
618
623
  end
619
624
 
@@ -622,7 +627,7 @@ class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::Seq
622
627
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#30
623
628
  def human_name; end
624
629
 
625
- # 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
626
631
  def match_length; end
627
632
  end
628
633
 
@@ -642,7 +647,7 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
642
647
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31
643
648
  def human_name; end
644
649
 
645
- # 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
646
651
  def match_length; end
647
652
 
648
653
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#19
@@ -666,7 +671,7 @@ end
666
671
 
667
672
  # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#3
668
673
  class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
669
- # 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
670
675
  def match_length; end
671
676
  end
672
677
 
@@ -709,7 +714,7 @@ end
709
714
  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2
710
715
  module Regexp::Expression::Conditional; end
711
716
 
712
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#25
717
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#29
713
718
  class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
714
719
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34
715
720
  def human_name; end
@@ -720,7 +725,7 @@ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
720
725
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#35
721
726
  def human_name; end
722
727
 
723
- # 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
724
729
  def match_length; end
725
730
 
726
731
  # Name or number of the referenced capturing group that determines state.
@@ -741,63 +746,73 @@ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
741
746
  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10
742
747
  def referenced_expression=(_arg0); end
743
748
 
749
+ # @return [Boolean]
750
+ #
751
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#24
752
+ def referential?; end
753
+
744
754
  private
745
755
 
746
756
  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#19
747
757
  def initialize_copy(orig); end
748
758
  end
749
759
 
750
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#27
760
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#31
751
761
  class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
752
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#30
762
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
753
763
  def <<(exp); end
754
764
 
755
765
  # @raise [TooManyBranches]
756
766
  #
757
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
767
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38
758
768
  def add_sequence(active_opts = T.unsafe(nil)); end
759
769
 
760
770
  # @raise [TooManyBranches]
761
771
  #
762
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
772
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#38
763
773
  def branch(active_opts = T.unsafe(nil)); end
764
774
 
765
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
775
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
766
776
  def branches; end
767
777
 
768
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#46
778
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
769
779
  def condition; end
770
780
 
771
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41
781
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#45
772
782
  def condition=(exp); end
773
783
 
774
784
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36
775
785
  def human_name; end
776
786
 
777
- # 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
778
788
  def match_length; end
779
789
 
780
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
790
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#66
781
791
  def parts; end
782
792
 
783
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
793
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
784
794
  def reference; end
785
795
 
786
796
  # Returns the value of attribute referenced_expression.
787
797
  #
788
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
798
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32
789
799
  def referenced_expression; end
790
800
 
791
801
  # Sets the attribute referenced_expression
792
802
  #
793
803
  # @param value the value to set the attribute referenced_expression to.
794
804
  #
795
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
805
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32
796
806
  def referenced_expression=(_arg0); end
797
807
 
808
+ # @return [Boolean]
809
+ #
810
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#62
811
+ def referential?; end
812
+
798
813
  private
799
814
 
800
- # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#62
815
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#70
801
816
  def initialize_copy(orig); end
802
817
  end
803
818
 
@@ -842,7 +857,7 @@ class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
842
857
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#5
843
858
  def codepoint; end
844
859
 
845
- # 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
846
861
  def match_length; end
847
862
  end
848
863
 
@@ -870,7 +885,7 @@ class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::
870
885
  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#53
871
886
  def codepoints; end
872
887
 
873
- # 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
874
889
  def match_length; end
875
890
  end
876
891
 
@@ -924,7 +939,7 @@ class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::Es
924
939
 
925
940
  # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2
926
941
  class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
927
- # 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
928
943
  def match_length; end
929
944
 
930
945
  # @raise [Regexp::Parser::Error]
@@ -941,7 +956,7 @@ module Regexp::Expression::Group; end
941
956
  #
942
957
  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#34
943
958
  class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
944
- # 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
945
960
  def match_length; end
946
961
  end
947
962
 
@@ -1101,7 +1116,7 @@ class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
1101
1116
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#39
1102
1117
  def human_name; end
1103
1118
 
1104
- # 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
1105
1120
  def match_length; end
1106
1121
  end
1107
1122
 
@@ -1110,16 +1125,16 @@ class Regexp::Expression::Literal < ::Regexp::Expression::Base
1110
1125
  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#40
1111
1126
  def human_name; end
1112
1127
 
1113
- # 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
1114
1129
  def match_length; end
1115
1130
  end
1116
1131
 
1117
- # 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
1118
1133
  Regexp::Expression::MatchLength = Regexp::MatchLength
1119
1134
 
1120
1135
  # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2
1121
1136
  class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
1122
- # 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
1123
1138
  def match_length; end
1124
1139
 
1125
1140
  # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#7
@@ -1268,13 +1283,13 @@ end
1268
1283
  #
1269
1284
  # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8
1270
1285
  class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
1271
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#28
1286
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27
1272
1287
  def quantify(*args); end
1273
1288
 
1274
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1289
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22
1275
1290
  def starts_at; end
1276
1291
 
1277
- # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1292
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#22
1278
1293
  def ts; end
1279
1294
 
1280
1295
  class << self
@@ -1368,7 +1383,7 @@ module Regexp::Expression::Shared
1368
1383
  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36
1369
1384
  def is?(test_token, test_type = T.unsafe(nil)); end
1370
1385
 
1371
- # source://regexp_parser//lib/regexp_parser/expression/shared.rb#83
1386
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#87
1372
1387
  def nesting_level=(lvl); end
1373
1388
 
1374
1389
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#71
@@ -1426,12 +1441,17 @@ module Regexp::Expression::Shared
1426
1441
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#63
1427
1442
  def quantified?; end
1428
1443
 
1429
- # source://regexp_parser//lib/regexp_parser/expression/shared.rb#89
1444
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#93
1430
1445
  def quantifier=(qtf); end
1431
1446
 
1432
1447
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#59
1433
1448
  def quantifier_affix(expression_format); end
1434
1449
 
1450
+ # @return [Boolean]
1451
+ #
1452
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#83
1453
+ def referential?; end
1454
+
1435
1455
  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#38
1436
1456
  def starts_at; end
1437
1457
 
@@ -1509,25 +1529,25 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1509
1529
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#18
1510
1530
  def <<(exp); end
1511
1531
 
1512
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1532
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1513
1533
  def [](*args, &block); end
1514
1534
 
1515
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1535
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1516
1536
  def at(*args, &block); end
1517
1537
 
1518
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#35
1538
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#34
1519
1539
  def dig(*indices); end
1520
1540
 
1521
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1541
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1522
1542
  def each(*args, &block); end
1523
1543
 
1524
1544
  # Iterates over the expressions of this expression as an array, passing
1525
1545
  # the expression and its index within its parent to the given block.
1526
1546
  #
1527
1547
  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#39
1528
- def each_expression(include_self = T.unsafe(nil)); end
1548
+ def each_expression(include_self = T.unsafe(nil), &block); end
1529
1549
 
1530
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1550
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1531
1551
  def empty?(*args, &block); end
1532
1552
 
1533
1553
  # Returns the value of attribute expressions.
@@ -1542,35 +1562,35 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1542
1562
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1543
1563
  def expressions=(_arg0); end
1544
1564
 
1545
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1565
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1546
1566
  def fetch(*args, &block); end
1547
1567
 
1548
1568
  # Returns a new array with the results of calling the given block once
1549
1569
  # for every expression. If a block is not given, returns an array with
1550
1570
  # each expression and its level index as an array.
1551
1571
  #
1552
- # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#50
1572
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#53
1553
1573
  def flat_map(include_self = T.unsafe(nil)); end
1554
1574
 
1555
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1575
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1556
1576
  def index(*args, &block); end
1557
1577
 
1558
- # 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
1559
1579
  def inner_match_length; end
1560
1580
 
1561
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1581
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1562
1582
  def join(*args, &block); end
1563
1583
 
1564
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1584
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1565
1585
  def last(*args, &block); end
1566
1586
 
1567
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1587
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1568
1588
  def length(*args, &block); end
1569
1589
 
1570
- # 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
1571
1591
  def match_length; end
1572
1592
 
1573
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#45
1593
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#44
1574
1594
  def parts; end
1575
1595
 
1576
1596
  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
@@ -1579,10 +1599,15 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1579
1599
  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
1580
1600
  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
1581
1601
 
1582
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#41
1602
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#40
1583
1603
  def te; end
1584
1604
 
1585
- # 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
1586
1611
  def to_h; end
1587
1612
 
1588
1613
  # Traverses the subexpression (depth-first, pre-order) and calls the given
@@ -1601,7 +1626,7 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1601
1626
  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#16
1602
1627
  def traverse(include_self = T.unsafe(nil), &block); end
1603
1628
 
1604
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#29
1629
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#28
1605
1630
  def values_at(*args, &block); end
1606
1631
 
1607
1632
  # Traverses the subexpression (depth-first, pre-order) and calls the given
@@ -1627,7 +1652,7 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1627
1652
  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13
1628
1653
  def initialize_copy(orig); end
1629
1654
 
1630
- # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#58
1655
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#61
1631
1656
  def intersperse(expressions, separator); end
1632
1657
  end
1633
1658
 
@@ -1656,7 +1681,7 @@ class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::Unic
1656
1681
 
1657
1682
  # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4
1658
1683
  class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
1659
- # 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
1660
1685
  def match_length; end
1661
1686
 
1662
1687
  # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#9
@@ -1897,95 +1922,150 @@ end
1897
1922
  #
1898
1923
  # source://regexp_parser//lib/regexp_parser/lexer.rb#5
1899
1924
  class Regexp::Lexer
1925
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#71
1926
+ def emit(token); end
1927
+
1900
1928
  # source://regexp_parser//lib/regexp_parser/lexer.rb#20
1901
- 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
1902
1930
 
1903
1931
  private
1904
1932
 
1905
- # source://regexp_parser//lib/regexp_parser/lexer.rb#71
1933
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#91
1906
1934
  def ascend(type, token); end
1907
1935
 
1908
- # 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
1909
1953
  def break_codepoint_list(token); end
1910
1954
 
1911
1955
  # called by scan to break a literal run that is longer than one character
1912
1956
  # into two separate tokens when it is followed by a quantifier
1913
1957
  #
1914
- # source://regexp_parser//lib/regexp_parser/lexer.rb#95
1958
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#115
1915
1959
  def break_literal(token); end
1916
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
+
1917
1973
  # Returns the value of attribute conditional_nesting.
1918
1974
  #
1919
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1975
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1920
1976
  def conditional_nesting; end
1921
1977
 
1922
1978
  # Sets the attribute conditional_nesting
1923
1979
  #
1924
1980
  # @param value the value to set the attribute conditional_nesting to.
1925
1981
  #
1926
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1982
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1927
1983
  def conditional_nesting=(_arg0); end
1928
1984
 
1929
- # source://regexp_parser//lib/regexp_parser/lexer.rb#82
1985
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#102
1930
1986
  def descend(type, token); end
1931
1987
 
1932
- # source://regexp_parser//lib/regexp_parser/lexer.rb#123
1933
- def merge_condition(current); end
1988
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#154
1989
+ def merge_condition(current, last); end
1934
1990
 
1935
1991
  # Returns the value of attribute nesting.
1936
1992
  #
1937
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
1993
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1938
1994
  def nesting; end
1939
1995
 
1940
1996
  # Sets the attribute nesting
1941
1997
  #
1942
1998
  # @param value the value to set the attribute nesting to.
1943
1999
  #
1944
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2000
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1945
2001
  def nesting=(_arg0); end
1946
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
+
1947
2027
  # Returns the value of attribute set_nesting.
1948
2028
  #
1949
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2029
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1950
2030
  def set_nesting; end
1951
2031
 
1952
2032
  # Sets the attribute set_nesting
1953
2033
  #
1954
2034
  # @param value the value to set the attribute set_nesting to.
1955
2035
  #
1956
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2036
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1957
2037
  def set_nesting=(_arg0); end
1958
2038
 
1959
2039
  # Returns the value of attribute shift.
1960
2040
  #
1961
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2041
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1962
2042
  def shift; end
1963
2043
 
1964
2044
  # Sets the attribute shift
1965
2045
  #
1966
2046
  # @param value the value to set the attribute shift to.
1967
2047
  #
1968
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2048
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1969
2049
  def shift=(_arg0); end
1970
2050
 
1971
2051
  # Returns the value of attribute tokens.
1972
2052
  #
1973
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2053
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1974
2054
  def tokens; end
1975
2055
 
1976
2056
  # Sets the attribute tokens
1977
2057
  #
1978
2058
  # @param value the value to set the attribute tokens to.
1979
2059
  #
1980
- # source://regexp_parser//lib/regexp_parser/lexer.rb#69
2060
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
1981
2061
  def tokens=(_arg0); end
1982
2062
 
1983
2063
  class << self
1984
2064
  # source://regexp_parser//lib/regexp_parser/lexer.rb#16
1985
- 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
1986
2066
 
1987
2067
  # source://regexp_parser//lib/regexp_parser/lexer.rb#16
1988
- 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
1989
2069
  end
1990
2070
  end
1991
2071
 
@@ -2112,7 +2192,7 @@ class Regexp::MatchLength
2112
2192
  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2113
2193
  def reify=(_arg0); end
2114
2194
 
2115
- # 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
2116
2196
  def test_regexp; end
2117
2197
 
2118
2198
  class << self
@@ -2375,175 +2455,197 @@ Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
2375
2455
  class Regexp::Scanner
2376
2456
  # Emits an array with the details of the scanned pattern
2377
2457
  #
2378
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2555
2458
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2591
2379
2459
  def emit(type, token, text); end
2380
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
+
2381
2471
  # @raise [PrematureEndError]
2382
2472
  #
2383
2473
  # source://regexp_parser//lib/regexp_parser/scanner.rb#84
2384
- 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
2385
2475
 
2386
2476
  private
2387
2477
 
2388
2478
  # Appends one or more characters to the literal buffer, to be emitted later
2389
2479
  # by a call to emit_literal.
2390
2480
  #
2391
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2606
2481
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2653
2392
2482
  def append_literal(data, ts, te); end
2393
2483
 
2394
2484
  # Returns the value of attribute block.
2395
2485
  #
2396
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2486
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2397
2487
  def block; end
2398
2488
 
2399
2489
  # Sets the attribute block
2400
2490
  #
2401
2491
  # @param value the value to set the attribute block to.
2402
2492
  #
2403
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2493
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2404
2494
  def block=(_arg0); end
2405
2495
 
2406
2496
  # Returns the value of attribute char_pos.
2407
2497
  #
2408
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2498
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2409
2499
  def char_pos; end
2410
2500
 
2411
2501
  # Sets the attribute char_pos
2412
2502
  #
2413
2503
  # @param value the value to set the attribute char_pos to.
2414
2504
  #
2415
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2505
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2416
2506
  def char_pos=(_arg0); end
2417
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
+
2418
2520
  # Returns the value of attribute conditional_stack.
2419
2521
  #
2420
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2522
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2421
2523
  def conditional_stack; end
2422
2524
 
2423
2525
  # Sets the attribute conditional_stack
2424
2526
  #
2425
2527
  # @param value the value to set the attribute conditional_stack to.
2426
2528
  #
2427
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2529
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2428
2530
  def conditional_stack=(_arg0); end
2429
2531
 
2430
2532
  # Copy from ts to te from data as text
2431
2533
  #
2432
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2600
2534
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2647
2433
2535
  def copy(data, ts, te); end
2434
2536
 
2435
2537
  # Emits the literal run collected by calls to the append_literal method.
2436
2538
  #
2437
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2612
2539
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2658
2438
2540
  def emit_literal; end
2439
2541
 
2440
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2647
2542
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2693
2441
2543
  def emit_meta_control_sequence(data, ts, te, token); end
2442
2544
 
2443
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2618
2545
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2664
2444
2546
  def emit_options(text); end
2445
2547
 
2446
2548
  # Returns the value of attribute free_spacing.
2447
2549
  #
2448
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2550
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2449
2551
  def free_spacing; end
2450
2552
 
2451
2553
  # Sets the attribute free_spacing
2452
2554
  #
2453
2555
  # @param value the value to set the attribute free_spacing to.
2454
2556
  #
2455
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2557
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2456
2558
  def free_spacing=(_arg0); end
2457
2559
 
2458
2560
  # @return [Boolean]
2459
2561
  #
2460
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2579
2562
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2626
2461
2563
  def free_spacing?(input_object, options); end
2462
2564
 
2463
2565
  # Returns the value of attribute group_depth.
2464
2566
  #
2465
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2567
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2466
2568
  def group_depth; end
2467
2569
 
2468
2570
  # Sets the attribute group_depth
2469
2571
  #
2470
2572
  # @param value the value to set the attribute group_depth to.
2471
2573
  #
2472
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2574
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2473
2575
  def group_depth=(_arg0); end
2474
2576
 
2475
2577
  # @return [Boolean]
2476
2578
  #
2477
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2591
2579
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2638
2478
2580
  def in_group?; end
2479
2581
 
2480
2582
  # @return [Boolean]
2481
2583
  #
2482
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2595
2584
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2642
2483
2585
  def in_set?; end
2484
2586
 
2485
- # Returns the value of attribute literal.
2587
+ # Returns the value of attribute prev_token.
2486
2588
  #
2487
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2488
- def literal; end
2589
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2590
+ def prev_token; end
2489
2591
 
2490
- # Sets the attribute literal
2592
+ # Sets the attribute prev_token
2491
2593
  #
2492
- # @param value the value to set the attribute literal to.
2594
+ # @param value the value to set the attribute prev_token to.
2493
2595
  #
2494
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2495
- def literal=(_arg0); end
2596
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2597
+ def prev_token=(_arg0); end
2496
2598
 
2497
2599
  # Returns the value of attribute set_depth.
2498
2600
  #
2499
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2601
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2500
2602
  def set_depth; end
2501
2603
 
2502
2604
  # Sets the attribute set_depth
2503
2605
  #
2504
2606
  # @param value the value to set the attribute set_depth to.
2505
2607
  #
2506
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2608
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2507
2609
  def set_depth=(_arg0); end
2508
2610
 
2509
2611
  # Returns the value of attribute spacing_stack.
2510
2612
  #
2511
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2613
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2512
2614
  def spacing_stack; end
2513
2615
 
2514
2616
  # Sets the attribute spacing_stack
2515
2617
  #
2516
2618
  # @param value the value to set the attribute spacing_stack to.
2517
2619
  #
2518
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2620
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2519
2621
  def spacing_stack=(_arg0); end
2520
2622
 
2521
2623
  # Returns the value of attribute tokens.
2522
2624
  #
2523
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2625
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2524
2626
  def tokens; end
2525
2627
 
2526
2628
  # Sets the attribute tokens
2527
2629
  #
2528
2630
  # @param value the value to set the attribute tokens to.
2529
2631
  #
2530
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2576
2632
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2620
2531
2633
  def tokens=(_arg0); end
2532
2634
 
2533
2635
  # Centralizes and unifies the handling of validation related
2534
2636
  # errors.
2535
2637
  #
2536
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2656
2638
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2702
2537
2639
  def validation_error(type, what, reason = T.unsafe(nil)); end
2538
2640
 
2539
2641
  class << self
2540
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2541
2642
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2577
2541
2643
  def long_prop_map; end
2542
2644
 
2543
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2545
2645
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2581
2544
2646
  def parse_prop_map(name); end
2545
2647
 
2546
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2549
2648
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2585
2547
2649
  def posix_classes; end
2548
2650
 
2549
2651
  # Scans the given regular expression text, or Regexp object and collects the
@@ -2554,11 +2656,11 @@ class Regexp::Scanner
2554
2656
  # --------------------------------------------------------------------------
2555
2657
  #
2556
2658
  # source://regexp_parser//lib/regexp_parser/scanner.rb#80
2557
- 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
2558
2660
 
2559
2661
  # lazy-load property maps when first needed
2560
2662
  #
2561
- # source://regexp_parser//lib/regexp_parser/scanner.rb#2537
2663
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2573
2562
2664
  def short_prop_map; end
2563
2665
  end
2564
2666
  end
@@ -2656,13 +2758,13 @@ end
2656
2758
  module Regexp::Syntax
2657
2759
  private
2658
2760
 
2659
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#62
2761
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2660
2762
  def comparable(name); end
2661
2763
 
2662
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#45
2764
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2663
2765
  def const_missing(const_name); end
2664
2766
 
2665
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#52
2767
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2666
2768
  def fallback_version_class(version); end
2667
2769
 
2668
2770
  # Returns the syntax specification class for the given syntax
@@ -2674,7 +2776,7 @@ module Regexp::Syntax
2674
2776
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2675
2777
  def new(name); end
2676
2778
 
2677
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#58
2779
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2678
2780
  def specified_versions; end
2679
2781
 
2680
2782
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
@@ -2683,17 +2785,14 @@ module Regexp::Syntax
2683
2785
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2684
2786
  def version_class(version); end
2685
2787
 
2686
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#67
2687
- def warn_if_future_version(const_name); end
2688
-
2689
2788
  class << self
2690
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#62
2789
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2691
2790
  def comparable(name); end
2692
2791
 
2693
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#45
2792
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2694
2793
  def const_missing(const_name); end
2695
2794
 
2696
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#52
2795
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2697
2796
  def fallback_version_class(version); end
2698
2797
 
2699
2798
  # Returns the syntax specification class for the given syntax
@@ -2705,7 +2804,7 @@ module Regexp::Syntax
2705
2804
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2706
2805
  def new(name); end
2707
2806
 
2708
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#58
2807
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2709
2808
  def specified_versions; end
2710
2809
 
2711
2810
  # @return [Boolean]
@@ -2715,9 +2814,6 @@ module Regexp::Syntax
2715
2814
 
2716
2815
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2717
2816
  def version_class(version); end
2718
-
2719
- # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#67
2720
- def warn_if_future_version(const_name); end
2721
2817
  end
2722
2818
  end
2723
2819
 
@@ -2822,6 +2918,9 @@ class Regexp::Syntax::Base
2822
2918
  end
2823
2919
  end
2824
2920
 
2921
+ # source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8
2922
+ Regexp::Syntax::CURRENT = Regexp::Syntax::V3_2_0
2923
+
2825
2924
  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6
2826
2925
  class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
2827
2926
  # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError