http_status_codes 0.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (42) hide show
  1. checksums.yaml +7 -0
  2. data/.rubocop.yml +8 -0
  3. data/.ruby-version +1 -0
  4. data/CHANGELOG.md +5 -0
  5. data/LICENSE.txt +21 -0
  6. data/README.md +48 -0
  7. data/Rakefile +12 -0
  8. data/lib/http_status_codes/version.rb +5 -0
  9. data/lib/http_status_codes.rb +77 -0
  10. data/sorbet/config +4 -0
  11. data/sorbet/rbi/annotations/.gitattributes +1 -0
  12. data/sorbet/rbi/annotations/minitest.rbi +119 -0
  13. data/sorbet/rbi/annotations/rainbow.rbi +269 -0
  14. data/sorbet/rbi/gems/.gitattributes +1 -0
  15. data/sorbet/rbi/gems/ast@2.4.2.rbi +585 -0
  16. data/sorbet/rbi/gems/erubi@1.13.1.rbi +157 -0
  17. data/sorbet/rbi/gems/json@2.9.1.rbi +1944 -0
  18. data/sorbet/rbi/gems/language_server-protocol@3.17.0.3.rbi +9 -0
  19. data/sorbet/rbi/gems/minitest@5.25.4.rbi +1547 -0
  20. data/sorbet/rbi/gems/netrc@0.11.0.rbi +159 -0
  21. data/sorbet/rbi/gems/parallel@1.26.3.rbi +291 -0
  22. data/sorbet/rbi/gems/parser@3.3.6.0.rbi +5519 -0
  23. data/sorbet/rbi/gems/prism@1.3.0.rbi +41403 -0
  24. data/sorbet/rbi/gems/racc@1.8.1.rbi +162 -0
  25. data/sorbet/rbi/gems/rainbow@3.1.1.rbi +403 -0
  26. data/sorbet/rbi/gems/rake@13.2.1.rbi +3022 -0
  27. data/sorbet/rbi/gems/rbi@0.2.2.rbi +4527 -0
  28. data/sorbet/rbi/gems/regexp_parser@2.10.0.rbi +3795 -0
  29. data/sorbet/rbi/gems/rubocop-ast@1.37.0.rbi +7608 -0
  30. data/sorbet/rbi/gems/rubocop@1.69.2.rbi +59462 -0
  31. data/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi +1318 -0
  32. data/sorbet/rbi/gems/spoom@1.5.0.rbi +4932 -0
  33. data/sorbet/rbi/gems/tapioca@0.16.5.rbi +3617 -0
  34. data/sorbet/rbi/gems/thor@1.3.2.rbi +4378 -0
  35. data/sorbet/rbi/gems/unicode-display_width@3.1.3.rbi +130 -0
  36. data/sorbet/rbi/gems/unicode-emoji@4.0.4.rbi +251 -0
  37. data/sorbet/rbi/gems/yard-sorbet@0.9.0.rbi +435 -0
  38. data/sorbet/rbi/gems/yard@0.9.37.rbi +18379 -0
  39. data/sorbet/rbi/shims/gems/minitest.rbi +3 -0
  40. data/sorbet/tapioca/config.yml +13 -0
  41. data/sorbet/tapioca/require.rb +4 -0
  42. metadata +100 -0
@@ -0,0 +1,3795 @@
1
+ # typed: true
2
+
3
+ # DO NOT EDIT MANUALLY
4
+ # This is an autogenerated file for types exported from the `regexp_parser` gem.
5
+ # Please instead update this file by running `bin/tapioca gem regexp_parser`.
6
+
7
+
8
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#1
9
+ module Regexp::Expression; end
10
+
11
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#5
12
+ class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
13
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
14
+ def alternatives; end
15
+
16
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#9
17
+ def human_name; end
18
+
19
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
20
+ def match_length; end
21
+ end
22
+
23
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#6
24
+ Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
25
+
26
+ # A sequence of expressions, used by Alternation as one of its alternatives.
27
+ #
28
+ # source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#3
29
+ class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence
30
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#10
31
+ def human_name; end
32
+ end
33
+
34
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#2
35
+ module Regexp::Expression::Anchor; end
36
+
37
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#18
38
+ Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
39
+
40
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#20
41
+ Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
42
+
43
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#3
44
+ class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
45
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
46
+ def match_length; end
47
+ end
48
+
49
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#5
50
+ class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base
51
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#11
52
+ def human_name; end
53
+ end
54
+
55
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#8
56
+ class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base
57
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#12
58
+ def human_name; end
59
+ end
60
+
61
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#19
62
+ Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine
63
+
64
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#21
65
+ Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
66
+
67
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#22
68
+ Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
69
+
70
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#6
71
+ class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base
72
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#13
73
+ def human_name; end
74
+ end
75
+
76
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#9
77
+ class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base
78
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#14
79
+ def human_name; end
80
+ end
81
+
82
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#11
83
+ class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base
84
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#15
85
+ def human_name; end
86
+ end
87
+
88
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#16
89
+ class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base
90
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#16
91
+ def human_name; end
92
+ end
93
+
94
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#14
95
+ class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base
96
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#17
97
+ def human_name; end
98
+
99
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#13
100
+ def negative?; end
101
+ end
102
+
103
+ # source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#13
104
+ class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base
105
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#18
106
+ def human_name; end
107
+ end
108
+
109
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#64
110
+ module Regexp::Expression::Assertion; end
111
+
112
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#65
113
+ class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
114
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
115
+ def match_length; end
116
+ end
117
+
118
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#67
119
+ class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base
120
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#19
121
+ def human_name; end
122
+ end
123
+
124
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#70
125
+ class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base
126
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#20
127
+ def human_name; end
128
+ end
129
+
130
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#68
131
+ class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base
132
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#21
133
+ def human_name; end
134
+
135
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#14
136
+ def negative?; end
137
+ end
138
+
139
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#71
140
+ class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base
141
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#22
142
+ def human_name; end
143
+
144
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#15
145
+ def negative?; end
146
+ end
147
+
148
+ # alias for symmetry between token symbol and Expression class name
149
+ #
150
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#55
151
+ Regexp::Expression::Backref = Regexp::Expression::Backreference
152
+
153
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#2
154
+ module Regexp::Expression::Backreference; end
155
+
156
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3
157
+ class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
158
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#155
159
+ def match_length; end
160
+
161
+ class << self
162
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#140
163
+ def referential?; end
164
+ end
165
+ end
166
+
167
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#15
168
+ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
169
+ # @return [Name] a new instance of Name
170
+ #
171
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#19
172
+ def initialize(token, options = T.unsafe(nil)); end
173
+
174
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23
175
+ def human_name; end
176
+
177
+ # Returns the value of attribute name.
178
+ #
179
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#16
180
+ def name; end
181
+
182
+ # Returns the value of attribute name.
183
+ #
184
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#16
185
+ def reference; end
186
+ end
187
+
188
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#31
189
+ class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
190
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24
191
+ def human_name; end
192
+ end
193
+
194
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#43
195
+ class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
196
+ # @return [NameRecursionLevel] a new instance of NameRecursionLevel
197
+ #
198
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#46
199
+ def initialize(token, options = T.unsafe(nil)); end
200
+
201
+ # Returns the value of attribute recursion_level.
202
+ #
203
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#44
204
+ def recursion_level; end
205
+ end
206
+
207
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#5
208
+ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
209
+ # @return [Number] a new instance of Number
210
+ #
211
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#9
212
+ def initialize(token, options = T.unsafe(nil)); end
213
+
214
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25
215
+ def human_name; end
216
+
217
+ # Returns the value of attribute number.
218
+ #
219
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#6
220
+ def number; end
221
+
222
+ # Returns the value of attribute number.
223
+ #
224
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#6
225
+ def reference; end
226
+ end
227
+
228
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#30
229
+ class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
230
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27
231
+ def human_name; end
232
+ end
233
+
234
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#32
235
+ class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
236
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28
237
+ def human_name; end
238
+ end
239
+
240
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
241
+ class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative
242
+ # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel
243
+ #
244
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#37
245
+ def initialize(token, options = T.unsafe(nil)); end
246
+
247
+ # Returns the value of attribute recursion_level.
248
+ #
249
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35
250
+ def recursion_level; end
251
+ end
252
+
253
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25
254
+ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
255
+ # Returns the value of attribute effective_number.
256
+ #
257
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#26
258
+ def effective_number; end
259
+
260
+ # Sets the attribute effective_number
261
+ #
262
+ # @param value the value to set the attribute effective_number to.
263
+ #
264
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#26
265
+ def effective_number=(_arg0); end
266
+
267
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26
268
+ def human_name; end
269
+
270
+ # Returns the value of attribute effective_number.
271
+ #
272
+ # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#26
273
+ def reference; end
274
+ end
275
+
276
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#2
277
+ class Regexp::Expression::Base
278
+ include ::Regexp::Expression::Shared
279
+ include ::Regexp::Expression::ReferencedExpressions
280
+ extend ::Regexp::Expression::Shared::ClassMethods
281
+
282
+ # @return [Base] a new instance of Base
283
+ #
284
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#5
285
+ def initialize(token, options = T.unsafe(nil)); end
286
+
287
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8
288
+ def =~(string, offset = T.unsafe(nil)); end
289
+
290
+ # @return [Boolean]
291
+ #
292
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25
293
+ def a?; end
294
+
295
+ # @return [Boolean]
296
+ #
297
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25
298
+ def ascii_classes?; end
299
+
300
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#60
301
+ def attributes; end
302
+
303
+ # @return [Boolean]
304
+ #
305
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
306
+ def case_insensitive?; end
307
+
308
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
309
+ def conditional_level; end
310
+
311
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
312
+ def conditional_level=(_arg0); end
313
+
314
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
315
+ def custom_to_s_handling; end
316
+
317
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
318
+ def custom_to_s_handling=(_arg0); end
319
+
320
+ # @return [Boolean]
321
+ #
322
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20
323
+ def d?; end
324
+
325
+ # @return [Boolean]
326
+ #
327
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20
328
+ def default_classes?; end
329
+
330
+ # @return [Boolean]
331
+ #
332
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
333
+ def extended?; end
334
+
335
+ # @return [Boolean]
336
+ #
337
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
338
+ def free_spacing?; end
339
+
340
+ # @return [Boolean]
341
+ #
342
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#47
343
+ def greedy?; end
344
+
345
+ # @return [Boolean]
346
+ #
347
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
348
+ def i?; end
349
+
350
+ # @return [Boolean]
351
+ #
352
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
353
+ def ignore_case?; end
354
+
355
+ # @return [Boolean]
356
+ #
357
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#51
358
+ def lazy?; end
359
+
360
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
361
+ def level; end
362
+
363
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
364
+ def level=(_arg0); end
365
+
366
+ # @return [Boolean]
367
+ #
368
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3
369
+ def m?; end
370
+
371
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8
372
+ def match(string, offset = T.unsafe(nil)); end
373
+
374
+ # @return [Boolean]
375
+ #
376
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3
377
+ def match?(string); end
378
+
379
+ # @return [Boolean]
380
+ #
381
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3
382
+ def matches?(string); end
383
+
384
+ # @return [Boolean]
385
+ #
386
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3
387
+ def multiline?; end
388
+
389
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
390
+ def nesting_level; end
391
+
392
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
393
+ def options; end
394
+
395
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
396
+ def options=(_arg0); end
397
+
398
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
399
+ def parent; end
400
+
401
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
402
+ def parent=(_arg0); end
403
+
404
+ # @return [Boolean]
405
+ #
406
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#56
407
+ def possessive?; end
408
+
409
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
410
+ def pre_quantifier_decorations; end
411
+
412
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
413
+ def pre_quantifier_decorations=(_arg0); end
414
+
415
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
416
+ def quantifier; end
417
+
418
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#17
419
+ def quantify(*args); end
420
+
421
+ # Deprecated. Prefer `#repetitions` which has a more uniform interface.
422
+ #
423
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#26
424
+ def quantity; end
425
+
426
+ # @return [Boolean]
427
+ #
428
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#51
429
+ def reluctant?; end
430
+
431
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#31
432
+ def repetitions; end
433
+
434
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
435
+ def set_level; end
436
+
437
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
438
+ def set_level=(_arg0); end
439
+
440
+ # %l Level (depth) of the expression. Returns 'root' for the root
441
+ # expression, returns zero or higher for all others.
442
+ #
443
+ # %> Indentation at expression's level.
444
+ #
445
+ # %x Index of the expression at its depth. Available when using
446
+ # the sprintf_tree method only.
447
+ #
448
+ # %s Start offset within the whole expression.
449
+ # %e End offset within the whole expression.
450
+ # %S Length of expression.
451
+ #
452
+ # %o Coded offset and length, same as '@%s+%S'
453
+ #
454
+ # %y Type of expression.
455
+ # %k Token of expression.
456
+ # %i ID, same as '%y:%k'
457
+ # %c Class name
458
+ #
459
+ # %q Quantifier info, as {m[,M]}
460
+ # %Q Quantifier text
461
+ #
462
+ # %z Quantifier min
463
+ # %Z Quantifier max
464
+ #
465
+ # %t Base text of the expression (excludes quantifier, if any)
466
+ # %~t Full text if the expression is terminal, otherwise %i
467
+ # %T Full text of the expression (includes quantifier, if any)
468
+ #
469
+ # %b Basic info, same as '%o %i'
470
+ # %m Most info, same as '%b %q'
471
+ # %a All info, same as '%m %t'
472
+ #
473
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37
474
+ def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
475
+
476
+ # %l Level (depth) of the expression. Returns 'root' for the root
477
+ # expression, returns zero or higher for all others.
478
+ #
479
+ # %> Indentation at expression's level.
480
+ #
481
+ # %x Index of the expression at its depth. Available when using
482
+ # the sprintf_tree method only.
483
+ #
484
+ # %s Start offset within the whole expression.
485
+ # %e End offset within the whole expression.
486
+ # %S Length of expression.
487
+ #
488
+ # %o Coded offset and length, same as '@%s+%S'
489
+ #
490
+ # %y Type of expression.
491
+ # %k Token of expression.
492
+ # %i ID, same as '%y:%k'
493
+ # %c Class name
494
+ #
495
+ # %q Quantifier info, as {m[,M]}
496
+ # %Q Quantifier text
497
+ #
498
+ # %z Quantifier min
499
+ # %Z Quantifier max
500
+ #
501
+ # %t Base text of the expression (excludes quantifier, if any)
502
+ # %~t Full text if the expression is terminal, otherwise %i
503
+ # %T Full text of the expression (includes quantifier, if any)
504
+ #
505
+ # %b Basic info, same as '%o %i'
506
+ # %m Most info, same as '%b %q'
507
+ # %a All info, same as '%m %t'
508
+ #
509
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37
510
+ def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
511
+
512
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
513
+ def te; end
514
+
515
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
516
+ def te=(_arg0); end
517
+
518
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
519
+ def text; end
520
+
521
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
522
+ def text=(_arg0); end
523
+
524
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#60
525
+ def to_h; end
526
+
527
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#9
528
+ def to_re(format = T.unsafe(nil)); end
529
+
530
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
531
+ def token; end
532
+
533
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
534
+ def token=(_arg0); end
535
+
536
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
537
+ def ts; end
538
+
539
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
540
+ def ts=(_arg0); end
541
+
542
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
543
+ def type; end
544
+
545
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
546
+ def type=(_arg0); end
547
+
548
+ # @return [Boolean]
549
+ #
550
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30
551
+ def u?; end
552
+
553
+ # @return [Boolean]
554
+ #
555
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30
556
+ def unicode_classes?; end
557
+
558
+ # source://regexp_parser//lib/regexp_parser/expression/base.rb#21
559
+ def unquantified_clone; end
560
+
561
+ # @return [Boolean]
562
+ #
563
+ # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
564
+ def x?; end
565
+ end
566
+
567
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#2
568
+ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
569
+ # @return [CharacterSet] a new instance of CharacterSet
570
+ #
571
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#6
572
+ def initialize(token, options = T.unsafe(nil)); end
573
+
574
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#16
575
+ def close; end
576
+
577
+ # Returns the value of attribute closed.
578
+ #
579
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
580
+ def closed; end
581
+
582
+ # Sets the attribute closed
583
+ #
584
+ # @param value the value to set the attribute closed to.
585
+ #
586
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
587
+ def closed=(_arg0); end
588
+
589
+ # Returns the value of attribute closed.
590
+ #
591
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
592
+ def closed?; end
593
+
594
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
595
+ def match_length; end
596
+
597
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#12
598
+ def negate; end
599
+
600
+ # Returns the value of attribute negative.
601
+ #
602
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
603
+ def negative; end
604
+
605
+ # Sets the attribute negative
606
+ #
607
+ # @param value the value to set the attribute negative to.
608
+ #
609
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
610
+ def negative=(_arg0); end
611
+
612
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#16
613
+ def negative?; end
614
+
615
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#15
616
+ def parts; end
617
+ end
618
+
619
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#3
620
+ class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
621
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#29
622
+ def human_name; end
623
+
624
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
625
+ def match_length; end
626
+ end
627
+
628
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#5
629
+ class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
630
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#30
631
+ def human_name; end
632
+
633
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
634
+ def match_length; end
635
+ end
636
+
637
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#6
638
+ Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
639
+
640
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#3
641
+ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
642
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#8
643
+ def <<(exp); end
644
+
645
+ # @return [Boolean]
646
+ #
647
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#14
648
+ def complete?; end
649
+
650
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31
651
+ def human_name; end
652
+
653
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
654
+ def match_length; end
655
+
656
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#16
657
+ def parts; end
658
+
659
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#4
660
+ def ts; end
661
+ end
662
+
663
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#2
664
+ module Regexp::Expression::CharacterType; end
665
+
666
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#5
667
+ class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base
668
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#32
669
+ def human_name; end
670
+ end
671
+
672
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#3
673
+ class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
674
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
675
+ def match_length; end
676
+
677
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#17
678
+ def negative?; end
679
+ end
680
+
681
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#6
682
+ class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
683
+
684
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#15
685
+ class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
686
+
687
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#8
688
+ class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
689
+
690
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#14
691
+ class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
692
+
693
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#7
694
+ class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
695
+
696
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#9
697
+ class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
698
+
699
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#13
700
+ class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
701
+
702
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#11
703
+ class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
704
+
705
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#12
706
+ class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
707
+
708
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#10
709
+ class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
710
+
711
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#8
712
+ class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace
713
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#33
714
+ def human_name; end
715
+
716
+ class << self
717
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#130
718
+ def comment?; end
719
+ end
720
+ end
721
+
722
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2
723
+ module Regexp::Expression::Conditional; end
724
+
725
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#18
726
+ class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
727
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34
728
+ def human_name; end
729
+ end
730
+
731
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#11
732
+ class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
733
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#35
734
+ def human_name; end
735
+
736
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
737
+ def match_length; end
738
+
739
+ # Name or number of the referenced capturing group that determines state.
740
+ # Returns a String if reference is by name, Integer if by number.
741
+ #
742
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#12
743
+ def reference; end
744
+
745
+ class << self
746
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#141
747
+ def referential?; end
748
+ end
749
+ end
750
+
751
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#20
752
+ class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
753
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#21
754
+ def <<(exp); end
755
+
756
+ # @raise [TooManyBranches]
757
+ #
758
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#25
759
+ def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
760
+
761
+ # @raise [TooManyBranches]
762
+ #
763
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#25
764
+ def branch(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
765
+
766
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41
767
+ def branches; end
768
+
769
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#37
770
+ def condition; end
771
+
772
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#32
773
+ def condition=(exp); end
774
+
775
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36
776
+ def human_name; end
777
+
778
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
779
+ def match_length; end
780
+
781
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#17
782
+ def parts; end
783
+
784
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#45
785
+ def reference; end
786
+
787
+ class << self
788
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#142
789
+ def referential?; end
790
+ end
791
+ end
792
+
793
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#3
794
+ class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
795
+ # @return [TooManyBranches] a new instance of TooManyBranches
796
+ #
797
+ # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#4
798
+ def initialize; end
799
+ end
800
+
801
+ # alias for symmetry between Token::* and Expression::*
802
+ #
803
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29
804
+ Regexp::Expression::Escape = Regexp::Expression::EscapeSequence
805
+
806
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#2
807
+ module Regexp::Expression::EscapeSequence; end
808
+
809
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22
810
+ class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
811
+ private
812
+
813
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#40
814
+ def control_sequence_to_s(control_sequence); end
815
+
816
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#45
817
+ def meta_char_to_codepoint(meta_char); end
818
+ end
819
+
820
+ # \e
821
+ #
822
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#5
823
+ class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base
824
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#2
825
+ def codepoint; end
826
+ end
827
+
828
+ # \b
829
+ #
830
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#6
831
+ class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base
832
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#3
833
+ def codepoint; end
834
+ end
835
+
836
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3
837
+ class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
838
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_char.rb#2
839
+ def char; end
840
+
841
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
842
+ def match_length; end
843
+ end
844
+
845
+ # \a
846
+ #
847
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#7
848
+ class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base
849
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#4
850
+ def codepoint; end
851
+ end
852
+
853
+ # e.g. \u000A
854
+ #
855
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#18
856
+ class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base
857
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#16
858
+ def codepoint; end
859
+ end
860
+
861
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#20
862
+ class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
863
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#20
864
+ def char; end
865
+
866
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#28
867
+ def chars; end
868
+
869
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#24
870
+ def codepoint; end
871
+
872
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#32
873
+ def codepoints; end
874
+
875
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#164
876
+ def match_length; end
877
+ end
878
+
879
+ # e.g. \cB
880
+ #
881
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#23
882
+ class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
883
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#52
884
+ def codepoint; end
885
+ end
886
+
887
+ # \f
888
+ #
889
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#8
890
+ class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base
891
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#5
892
+ def codepoint; end
893
+ end
894
+
895
+ # e.g. \x0A
896
+ #
897
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#17
898
+ class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base
899
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#15
900
+ def codepoint; end
901
+ end
902
+
903
+ # e.g. \j, \@, \😀 (ineffectual escapes)
904
+ #
905
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#14
906
+ class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
907
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#11
908
+ def codepoint; end
909
+ end
910
+
911
+ # e.g. \M-Z
912
+ #
913
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#24
914
+ class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
915
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#58
916
+ def codepoint; end
917
+ end
918
+
919
+ # e.g. \M-\cX
920
+ #
921
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#25
922
+ class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
923
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#64
924
+ def codepoint; end
925
+ end
926
+
927
+ # \n
928
+ #
929
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#9
930
+ class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base
931
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#6
932
+ def codepoint; end
933
+ end
934
+
935
+ # e.g. \012
936
+ #
937
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#16
938
+ class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
939
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#13
940
+ def codepoint; end
941
+ end
942
+
943
+ # \r
944
+ #
945
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#10
946
+ class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base
947
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#7
948
+ def codepoint; end
949
+ end
950
+
951
+ # \t
952
+ #
953
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#11
954
+ class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base
955
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#8
956
+ def codepoint; end
957
+ end
958
+
959
+ # \v
960
+ #
961
+ # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#12
962
+ class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base
963
+ # source://regexp_parser//lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb#9
964
+ def codepoint; end
965
+ end
966
+
967
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2
968
+ class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
969
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
970
+ def match_length; end
971
+
972
+ # @raise [Regexp::Parser::Error]
973
+ #
974
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#3
975
+ def quantify(*_args); end
976
+
977
+ class << self
978
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#135
979
+ def decorative?; end
980
+ end
981
+ end
982
+
983
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#2
984
+ module Regexp::Expression::Group; end
985
+
986
+ # Special case. Absence group can match 0.. chars, irrespective of content.
987
+ # TODO: in theory, they *can* exclude match lengths with `.`: `(?~.{3})`
988
+ #
989
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#19
990
+ class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
991
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#172
992
+ def match_length; end
993
+ end
994
+
995
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#20
996
+ class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
997
+
998
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#3
999
+ class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
1000
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#18
1001
+ def parts; end
1002
+ end
1003
+
1004
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#40
1005
+ class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
1006
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#37
1007
+ def human_name; end
1008
+
1009
+ # Returns the value of attribute number.
1010
+ #
1011
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1012
+ def identifier; end
1013
+
1014
+ # Returns the value of attribute number.
1015
+ #
1016
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1017
+ def number; end
1018
+
1019
+ # Sets the attribute number
1020
+ #
1021
+ # @param value the value to set the attribute number to.
1022
+ #
1023
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1024
+ def number=(_arg0); end
1025
+
1026
+ # Returns the value of attribute number_at_level.
1027
+ #
1028
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1029
+ def number_at_level; end
1030
+
1031
+ # Sets the attribute number_at_level
1032
+ #
1033
+ # @param value the value to set the attribute number_at_level to.
1034
+ #
1035
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
1036
+ def number_at_level=(_arg0); end
1037
+
1038
+ class << self
1039
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#126
1040
+ def capturing?; end
1041
+ end
1042
+ end
1043
+
1044
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#60
1045
+ class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
1046
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#20
1047
+ def parts; end
1048
+
1049
+ class << self
1050
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#131
1051
+ def comment?; end
1052
+
1053
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#136
1054
+ def decorative?; end
1055
+ end
1056
+ end
1057
+
1058
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#45
1059
+ class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
1060
+ # @return [Named] a new instance of Named
1061
+ #
1062
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#49
1063
+ def initialize(token, options = T.unsafe(nil)); end
1064
+
1065
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#38
1066
+ def human_name; end
1067
+
1068
+ # Returns the value of attribute name.
1069
+ #
1070
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46
1071
+ def identifier; end
1072
+
1073
+ # Returns the value of attribute name.
1074
+ #
1075
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46
1076
+ def name; end
1077
+
1078
+ private
1079
+
1080
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#54
1081
+ def initialize_copy(orig); end
1082
+ end
1083
+
1084
+ # TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no
1085
+ # longer inherit from Group because it is effectively a terminal expression.
1086
+ #
1087
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#23
1088
+ class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
1089
+ # Returns the value of attribute option_changes.
1090
+ #
1091
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24
1092
+ def option_changes; end
1093
+
1094
+ # Sets the attribute option_changes
1095
+ #
1096
+ # @param value the value to set the attribute option_changes to.
1097
+ #
1098
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24
1099
+ def option_changes=(_arg0); end
1100
+
1101
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#31
1102
+ def quantify(*args); end
1103
+
1104
+ private
1105
+
1106
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#26
1107
+ def initialize_copy(orig); end
1108
+ end
1109
+
1110
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#6
1111
+ class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
1112
+ # @return [Passive] a new instance of Passive
1113
+ #
1114
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#9
1115
+ def initialize(*_arg0); end
1116
+
1117
+ # Sets the attribute implicit
1118
+ #
1119
+ # @param value the value to set the attribute implicit to.
1120
+ #
1121
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#7
1122
+ def implicit=(_arg0); end
1123
+
1124
+ # @return [Boolean]
1125
+ #
1126
+ # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#14
1127
+ def implicit?; end
1128
+
1129
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#19
1130
+ def parts; end
1131
+ end
1132
+
1133
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#2
1134
+ module Regexp::Expression::Keep; end
1135
+
1136
+ # TODO: in regexp_parser v3.0.0 this should possibly be a Subexpression
1137
+ # that contains all expressions to its left.
1138
+ #
1139
+ # source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#5
1140
+ class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
1141
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#39
1142
+ def human_name; end
1143
+
1144
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
1145
+ def match_length; end
1146
+ end
1147
+
1148
+ # source://regexp_parser//lib/regexp_parser/expression/classes/literal.rb#2
1149
+ class Regexp::Expression::Literal < ::Regexp::Expression::Base
1150
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#40
1151
+ def human_name; end
1152
+
1153
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#105
1154
+ def match_length; end
1155
+ end
1156
+
1157
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#85
1158
+ Regexp::Expression::MatchLength = Regexp::MatchLength
1159
+
1160
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#10
1161
+ Regexp::Expression::Nonposixclass = Regexp::Expression::PosixClass
1162
+
1163
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#118
1164
+ Regexp::Expression::Nonproperty = Regexp::Expression::UnicodeProperty
1165
+
1166
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2
1167
+ class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
1168
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1169
+ def match_length; end
1170
+
1171
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#3
1172
+ def name; end
1173
+
1174
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#18
1175
+ def negative?; end
1176
+ end
1177
+
1178
+ # alias for symmetry between token symbol and Expression class name
1179
+ #
1180
+ # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#9
1181
+ Regexp::Expression::Posixclass = Regexp::Expression::PosixClass
1182
+
1183
+ # alias for symmetry between token symbol and Expression class name
1184
+ #
1185
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#117
1186
+ Regexp::Expression::Property = Regexp::Expression::UnicodeProperty
1187
+
1188
+ # TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and
1189
+ # call super in #initialize, but raise in #quantifier= and #quantify,
1190
+ # or introduce an Expression::Quantifiable intermediate class.
1191
+ # Or actually allow chaining as a more concise but tricky solution than PR#69.
1192
+ #
1193
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#6
1194
+ class Regexp::Expression::Quantifier
1195
+ include ::Regexp::Expression::Shared
1196
+ extend ::Regexp::Expression::Shared::ClassMethods
1197
+
1198
+ # @return [Quantifier] a new instance of Quantifier
1199
+ #
1200
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11
1201
+ def initialize(*args); end
1202
+
1203
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1204
+ def conditional_level; end
1205
+
1206
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1207
+ def conditional_level=(_arg0); end
1208
+
1209
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1210
+ def custom_to_s_handling; end
1211
+
1212
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1213
+ def custom_to_s_handling=(_arg0); end
1214
+
1215
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1216
+ def greedy?; end
1217
+
1218
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1219
+ def lazy?; end
1220
+
1221
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1222
+ def level; end
1223
+
1224
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1225
+ def level=(_arg0); end
1226
+
1227
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#42
1228
+ def max; end
1229
+
1230
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#38
1231
+ def min; end
1232
+
1233
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#46
1234
+ def mode; end
1235
+
1236
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
1237
+ def nesting_level; end
1238
+
1239
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1240
+ def options; end
1241
+
1242
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1243
+ def options=(_arg0); end
1244
+
1245
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1246
+ def parent; end
1247
+
1248
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1249
+ def parent=(_arg0); end
1250
+
1251
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1252
+ def possessive?; end
1253
+
1254
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1255
+ def pre_quantifier_decorations; end
1256
+
1257
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1258
+ def pre_quantifier_decorations=(_arg0); end
1259
+
1260
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
1261
+ def quantifier; end
1262
+
1263
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
1264
+ def reluctant?; end
1265
+
1266
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1267
+ def set_level; end
1268
+
1269
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1270
+ def set_level=(_arg0); end
1271
+
1272
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1273
+ def te; end
1274
+
1275
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1276
+ def te=(_arg0); end
1277
+
1278
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1279
+ def text; end
1280
+
1281
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1282
+ def text=(_arg0); end
1283
+
1284
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#19
1285
+ def to_h; end
1286
+
1287
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1288
+ def token; end
1289
+
1290
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1291
+ def token=(_arg0); end
1292
+
1293
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1294
+ def ts; end
1295
+
1296
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1297
+ def ts=(_arg0); end
1298
+
1299
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1300
+ def type; end
1301
+
1302
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1303
+ def type=(_arg0); end
1304
+
1305
+ private
1306
+
1307
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#52
1308
+ def deprecated_old_init(token, text, _min, _max, _mode = T.unsafe(nil)); end
1309
+
1310
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#64
1311
+ def derived_data; end
1312
+ end
1313
+
1314
+ # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#9
1315
+ Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
1316
+
1317
+ # source://regexp_parser//lib/regexp_parser/expression/methods/referenced_expressions.rb#2
1318
+ module Regexp::Expression::ReferencedExpressions
1319
+ # source://regexp_parser//lib/regexp_parser/expression/methods/referenced_expressions.rb#5
1320
+ def referenced_expression; end
1321
+
1322
+ # Returns the value of attribute referenced_expressions.
1323
+ #
1324
+ # source://regexp_parser//lib/regexp_parser/expression/methods/referenced_expressions.rb#3
1325
+ def referenced_expressions; end
1326
+
1327
+ # Sets the attribute referenced_expressions
1328
+ #
1329
+ # @param value the value to set the attribute referenced_expressions to.
1330
+ #
1331
+ # source://regexp_parser//lib/regexp_parser/expression/methods/referenced_expressions.rb#3
1332
+ def referenced_expressions=(_arg0); end
1333
+
1334
+ private
1335
+
1336
+ # source://regexp_parser//lib/regexp_parser/expression/methods/referenced_expressions.rb#9
1337
+ def initialize_copy(orig); end
1338
+ end
1339
+
1340
+ # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#2
1341
+ class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
1342
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#41
1343
+ def human_name; end
1344
+
1345
+ class << self
1346
+ # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#3
1347
+ def build(options = T.unsafe(nil)); end
1348
+ end
1349
+ end
1350
+
1351
+ # A sequence of expressions. Differs from a Subexpressions by how it handles
1352
+ # quantifiers, as it applies them to its last element instead of itself as
1353
+ # a whole subexpression.
1354
+ #
1355
+ # Used as the base class for the Alternation alternatives, Conditional
1356
+ # branches, and CharacterSet::Intersection intersected sequences.
1357
+ #
1358
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8
1359
+ class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
1360
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27
1361
+ def quantify(token, *args); end
1362
+
1363
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
1364
+ def ts; end
1365
+
1366
+ class << self
1367
+ # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#10
1368
+ def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
1369
+ end
1370
+ end
1371
+
1372
+ # abstract class
1373
+ #
1374
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#3
1375
+ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
1376
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#12
1377
+ def <<(exp); end
1378
+
1379
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#16
1380
+ def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
1381
+
1382
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1383
+ def operands; end
1384
+
1385
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
1386
+ def operator; end
1387
+
1388
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#22
1389
+ def parts; end
1390
+
1391
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1392
+ def sequences; end
1393
+
1394
+ # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#8
1395
+ def ts; end
1396
+ end
1397
+
1398
+ # alias for symmetry between token symbol and Expression class name
1399
+ #
1400
+ # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#22
1401
+ Regexp::Expression::Set = Regexp::Expression::CharacterSet
1402
+
1403
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#2
1404
+ module Regexp::Expression::Shared
1405
+ mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
1406
+
1407
+ # Deep-compare two expressions for equality.
1408
+ #
1409
+ # When changing the conditions, please make sure to update
1410
+ # #pretty_print_instance_variables so that it includes all relevant values.
1411
+ #
1412
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
1413
+ def ==(other); end
1414
+
1415
+ # Deep-compare two expressions for equality.
1416
+ #
1417
+ # When changing the conditions, please make sure to update
1418
+ # #pretty_print_instance_variables so that it includes all relevant values.
1419
+ #
1420
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
1421
+ def ===(other); end
1422
+
1423
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#51
1424
+ def base_length; end
1425
+
1426
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#124
1427
+ def capturing?; end
1428
+
1429
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#96
1430
+ def coded_offset; end
1431
+
1432
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#128
1433
+ def comment?; end
1434
+
1435
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#133
1436
+ def decorative?; end
1437
+
1438
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#47
1439
+ def ends_at(include_quantifier = T.unsafe(nil)); end
1440
+
1441
+ # Deep-compare two expressions for equality.
1442
+ #
1443
+ # When changing the conditions, please make sure to update
1444
+ # #pretty_print_instance_variables so that it includes all relevant values.
1445
+ #
1446
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
1447
+ def eql?(other); end
1448
+
1449
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#55
1450
+ def full_length; end
1451
+
1452
+ # default implementation, e.g. "atomic group", "hex escape", "word type", ..
1453
+ #
1454
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#4
1455
+ def human_name; end
1456
+
1457
+ # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#3
1458
+ def inspect; end
1459
+
1460
+ # Test if this expression has the given test_token, and optionally a given
1461
+ # test_type.
1462
+ #
1463
+ # # Any expressions
1464
+ # exp.is? :* # always returns true
1465
+ #
1466
+ # # is it a :capture
1467
+ # exp.is? :capture
1468
+ #
1469
+ # # is it a :character and a :set
1470
+ # exp.is? :character, :set
1471
+ #
1472
+ # # is it a :meta :dot
1473
+ # exp.is? :dot, :meta
1474
+ #
1475
+ # # is it a :meta or :escape :dot
1476
+ # exp.is? :dot, [:meta, :escape]
1477
+ #
1478
+ # @return [Boolean]
1479
+ #
1480
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36
1481
+ def is?(test_token, test_type = T.unsafe(nil)); end
1482
+
1483
+ # not an alias so as to respect overrides of #negative?
1484
+ #
1485
+ # @return [Boolean]
1486
+ #
1487
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#8
1488
+ def negated?; end
1489
+
1490
+ # @return [Boolean]
1491
+ #
1492
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#3
1493
+ def negative?; end
1494
+
1495
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#100
1496
+ def nesting_level=(lvl); end
1497
+
1498
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#92
1499
+ def offset; end
1500
+
1501
+ # Test if this expression matches an entry in the given scope spec.
1502
+ #
1503
+ # A scope spec can be one of:
1504
+ #
1505
+ # . An array: Interpreted as a set of tokens, tested for inclusion
1506
+ # of the expression's token.
1507
+ #
1508
+ # . A hash: Where the key is interpreted as the expression type
1509
+ # and the value is either a symbol or an array. In this
1510
+ # case, when the scope is a hash, one_of? calls itself to
1511
+ # evaluate the key's value.
1512
+ #
1513
+ # . A symbol: matches the expression's token or type, depending on
1514
+ # the level of the call. If one_of? is called directly with
1515
+ # a symbol then it will always be checked against the
1516
+ # type of the expression. If it's being called for a value
1517
+ # from a hash, it will be checked against the token of the
1518
+ # expression.
1519
+ #
1520
+ # # any expression
1521
+ # exp.one_of?(:*) # always true
1522
+ #
1523
+ # # like exp.type?(:group)
1524
+ # exp.one_of?(:group)
1525
+ #
1526
+ # # any expression of type meta
1527
+ # exp.one_of?(:meta => :*)
1528
+ #
1529
+ # # meta dots and alternations
1530
+ # exp.one_of?(:meta => [:dot, :alternation])
1531
+ #
1532
+ # # meta dots and any set tokens
1533
+ # exp.one_of?({meta: [:dot], set: :*})
1534
+ #
1535
+ # @return [Boolean]
1536
+ #
1537
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#75
1538
+ def one_of?(scope, top = T.unsafe(nil)); end
1539
+
1540
+ # @return [Boolean]
1541
+ #
1542
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#111
1543
+ def optional?; end
1544
+
1545
+ # default implementation
1546
+ #
1547
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#4
1548
+ def parts; end
1549
+
1550
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#84
1551
+ def pre_quantifier_decoration(expression_format = T.unsafe(nil)); end
1552
+
1553
+ # Make pretty-print work despite #inspect implementation.
1554
+ #
1555
+ # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#12
1556
+ def pretty_print(q); end
1557
+
1558
+ # Called by pretty_print (ruby/pp) and #inspect.
1559
+ #
1560
+ # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#17
1561
+ def pretty_print_instance_variables; end
1562
+
1563
+ # @return [Boolean]
1564
+ #
1565
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#115
1566
+ def quantified?; end
1567
+
1568
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#106
1569
+ def quantifier=(qtf); end
1570
+
1571
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#88
1572
+ def quantifier_affix(expression_format = T.unsafe(nil)); end
1573
+
1574
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#138
1575
+ def referential?; end
1576
+
1577
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#43
1578
+ def starts_at; end
1579
+
1580
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#120
1581
+ def terminal?; end
1582
+
1583
+ # #to_s reproduces the original source, as an unparser would.
1584
+ #
1585
+ # It takes an optional format argument.
1586
+ #
1587
+ # Example:
1588
+ #
1589
+ # lit = Regexp::Parser.parse(/a +/x)[0]
1590
+ #
1591
+ # lit.to_s # => 'a+' # default; with quantifier
1592
+ # lit.to_s(:full) # => 'a+' # default; with quantifier
1593
+ # lit.to_s(:base) # => 'a' # without quantifier
1594
+ # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
1595
+ #
1596
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72
1597
+ def to_s(format = T.unsafe(nil)); end
1598
+
1599
+ # #to_s reproduces the original source, as an unparser would.
1600
+ #
1601
+ # It takes an optional format argument.
1602
+ #
1603
+ # Example:
1604
+ #
1605
+ # lit = Regexp::Parser.parse(/a +/x)[0]
1606
+ #
1607
+ # lit.to_s # => 'a+' # default; with quantifier
1608
+ # lit.to_s(:full) # => 'a+' # default; with quantifier
1609
+ # lit.to_s(:base) # => 'a' # without quantifier
1610
+ # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
1611
+ #
1612
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72
1613
+ def to_str(format = T.unsafe(nil)); end
1614
+
1615
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#37
1616
+ def token_class; end
1617
+
1618
+ # Test if this expression has the given test_type, which can be either
1619
+ # a symbol or an array of symbols to check against the expression's type.
1620
+ #
1621
+ # # is it a :group expression
1622
+ # exp.type? :group
1623
+ #
1624
+ # # is it a :set, or :meta
1625
+ # exp.type? [:set, :meta]
1626
+ #
1627
+ # @return [Boolean]
1628
+ #
1629
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#13
1630
+ def type?(test_type); end
1631
+
1632
+ private
1633
+
1634
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#18
1635
+ def init_from_token_and_options(token, options = T.unsafe(nil)); end
1636
+
1637
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#32
1638
+ def initialize_copy(orig); end
1639
+
1640
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#10
1641
+ def intersperse(expressions, separator); end
1642
+
1643
+ class << self
1644
+ # @private
1645
+ #
1646
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#5
1647
+ def included(mod); end
1648
+ end
1649
+ end
1650
+
1651
+ # filled in ./methods/*.rb
1652
+ #
1653
+ # source://regexp_parser//lib/regexp_parser/expression/shared.rb#3
1654
+ module Regexp::Expression::Shared::ClassMethods
1655
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#125
1656
+ def capturing?; end
1657
+
1658
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#129
1659
+ def comment?; end
1660
+
1661
+ # Convenience method to init a valid Expression without a Regexp::Token
1662
+ #
1663
+ # @raise [ArgumentError]
1664
+ #
1665
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#5
1666
+ def construct(params = T.unsafe(nil)); end
1667
+
1668
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#15
1669
+ def construct_defaults; end
1670
+
1671
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#134
1672
+ def decorative?; end
1673
+
1674
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#139
1675
+ def referential?; end
1676
+
1677
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#121
1678
+ def terminal?; end
1679
+
1680
+ # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#25
1681
+ def token_class; end
1682
+ end
1683
+
1684
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#2
1685
+ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
1686
+ include ::Enumerable
1687
+
1688
+ # @return [Subexpression] a new instance of Subexpression
1689
+ #
1690
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#7
1691
+ def initialize(token, options = T.unsafe(nil)); end
1692
+
1693
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#20
1694
+ def <<(exp); end
1695
+
1696
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1697
+ def [](*args, &block); end
1698
+
1699
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1700
+ def at(*args, &block); end
1701
+
1702
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#33
1703
+ def dig(*indices); end
1704
+
1705
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1706
+ def each(*args, &block); end
1707
+
1708
+ # Traverses the expression, passing each recursive child to the
1709
+ # given block.
1710
+ # If the block takes two arguments, the indices of the children within
1711
+ # their parents are also passed to it.
1712
+ #
1713
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#8
1714
+ def each_expression(include_self = T.unsafe(nil), &block); end
1715
+
1716
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1717
+ def empty?(*args, &block); end
1718
+
1719
+ # Returns the value of attribute expressions.
1720
+ #
1721
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1722
+ def expressions; end
1723
+
1724
+ # Sets the attribute expressions
1725
+ #
1726
+ # @param value the value to set the attribute expressions to.
1727
+ #
1728
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
1729
+ def expressions=(_arg0); end
1730
+
1731
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#50
1732
+ def extract_quantifier_target(quantifier_description); end
1733
+
1734
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1735
+ def fetch(*args, &block); end
1736
+
1737
+ # Returns a new array with the results of calling the given block once
1738
+ # for every expression. If a block is not given, returns an array with
1739
+ # each expression and its level index as an array.
1740
+ #
1741
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#56
1742
+ def flat_map(include_self = T.unsafe(nil), &block); end
1743
+
1744
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1745
+ def index(*args, &block); end
1746
+
1747
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#118
1748
+ def inner_match_length; end
1749
+
1750
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1751
+ def join(*args, &block); end
1752
+
1753
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1754
+ def last(*args, &block); end
1755
+
1756
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1757
+ def length(*args, &block); end
1758
+
1759
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#111
1760
+ def match_length; end
1761
+
1762
+ # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#21
1763
+ def parts; end
1764
+
1765
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
1766
+ def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
1767
+
1768
+ # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
1769
+ def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
1770
+
1771
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#39
1772
+ def te; end
1773
+
1774
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#43
1775
+ def to_h; end
1776
+
1777
+ # Traverses the subexpression (depth-first, pre-order) and calls the given
1778
+ # block for each expression with three arguments; the traversal event,
1779
+ # the expression, and the index of the expression within its parent.
1780
+ #
1781
+ # The event argument is passed as follows:
1782
+ #
1783
+ # - For subexpressions, :enter upon entering the subexpression, and
1784
+ # :exit upon exiting it.
1785
+ #
1786
+ # - For terminal expressions, :visit is called once.
1787
+ #
1788
+ # Returns self.
1789
+ #
1790
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32
1791
+ def traverse(include_self = T.unsafe(nil), &block); end
1792
+
1793
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
1794
+ def values_at(*args, &block); end
1795
+
1796
+ # Traverses the subexpression (depth-first, pre-order) and calls the given
1797
+ # block for each expression with three arguments; the traversal event,
1798
+ # the expression, and the index of the expression within its parent.
1799
+ #
1800
+ # The event argument is passed as follows:
1801
+ #
1802
+ # - For subexpressions, :enter upon entering the subexpression, and
1803
+ # :exit upon exiting it.
1804
+ #
1805
+ # - For terminal expressions, :visit is called once.
1806
+ #
1807
+ # Returns self.
1808
+ #
1809
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32
1810
+ def walk(include_self = T.unsafe(nil), &block); end
1811
+
1812
+ protected
1813
+
1814
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#66
1815
+ def each_expression_with_index(&block); end
1816
+
1817
+ # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#73
1818
+ def each_expression_without_index(&block); end
1819
+
1820
+ private
1821
+
1822
+ # Override base method to clone the expressions as well.
1823
+ #
1824
+ # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13
1825
+ def initialize_copy(orig); end
1826
+
1827
+ class << self
1828
+ # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#122
1829
+ def terminal?; end
1830
+ end
1831
+ end
1832
+
1833
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#2
1834
+ module Regexp::Expression::UnicodeProperty; end
1835
+
1836
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108
1837
+ class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
1838
+
1839
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#13
1840
+ class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
1841
+
1842
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#14
1843
+ class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
1844
+
1845
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31
1846
+ class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
1847
+
1848
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#15
1849
+ class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
1850
+
1851
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#32
1852
+ class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
1853
+
1854
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3
1855
+ class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
1856
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
1857
+ def match_length; end
1858
+
1859
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4
1860
+ def name; end
1861
+
1862
+ # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#19
1863
+ def negative?; end
1864
+
1865
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#8
1866
+ def shortcut; end
1867
+ end
1868
+
1869
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#16
1870
+ class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
1871
+
1872
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109
1873
+ class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
1874
+
1875
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#17
1876
+ class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
1877
+
1878
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97
1879
+ module Regexp::Expression::UnicodeProperty::Codepoint; end
1880
+
1881
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#100
1882
+ class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1883
+
1884
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98
1885
+ class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1886
+
1887
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#101
1888
+ class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1889
+
1890
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102
1891
+ class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1892
+
1893
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#104
1894
+ class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1895
+
1896
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#103
1897
+ class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1898
+
1899
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105
1900
+ class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
1901
+
1902
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#110
1903
+ class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
1904
+
1905
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18
1906
+ class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
1907
+
1908
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#111
1909
+ class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
1910
+
1911
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#112
1912
+ class Regexp::Expression::UnicodeProperty::Enumerated < ::Regexp::Expression::UnicodeProperty::Base; end
1913
+
1914
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19
1915
+ class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
1916
+
1917
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#34
1918
+ module Regexp::Expression::UnicodeProperty::Letter; end
1919
+
1920
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#37
1921
+ class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1922
+
1923
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#35
1924
+ class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1925
+
1926
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#38
1927
+ class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1928
+
1929
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#40
1930
+ class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1931
+
1932
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42
1933
+ class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1934
+
1935
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43
1936
+ class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1937
+
1938
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#41
1939
+ class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1940
+
1941
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39
1942
+ class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
1943
+
1944
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20
1945
+ class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
1946
+
1947
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46
1948
+ module Regexp::Expression::UnicodeProperty::Mark; end
1949
+
1950
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#49
1951
+ class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1952
+
1953
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47
1954
+ class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1955
+
1956
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#50
1957
+ class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1958
+
1959
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#53
1960
+ class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1961
+
1962
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51
1963
+ class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1964
+
1965
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#52
1966
+ class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
1967
+
1968
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29
1969
+ class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
1970
+
1971
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56
1972
+ module Regexp::Expression::UnicodeProperty::Number; end
1973
+
1974
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#59
1975
+ class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1976
+
1977
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57
1978
+ class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
1979
+
1980
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#60
1981
+ class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1982
+
1983
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61
1984
+ class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1985
+
1986
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#62
1987
+ class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
1988
+
1989
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21
1990
+ class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
1991
+
1992
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22
1993
+ class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
1994
+
1995
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65
1996
+ module Regexp::Expression::UnicodeProperty::Punctuation; end
1997
+
1998
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#68
1999
+ class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2000
+
2001
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66
2002
+ class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
2003
+
2004
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#72
2005
+ class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2006
+
2007
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#69
2008
+ class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2009
+
2010
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70
2011
+ class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2012
+
2013
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74
2014
+ class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2015
+
2016
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73
2017
+ class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2018
+
2019
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#71
2020
+ class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2021
+
2022
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75
2023
+ class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
2024
+
2025
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113
2026
+ class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
2027
+
2028
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78
2029
+ module Regexp::Expression::UnicodeProperty::Separator; end
2030
+
2031
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#81
2032
+ class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
2033
+
2034
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79
2035
+ class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
2036
+
2037
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83
2038
+ class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
2039
+
2040
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#84
2041
+ class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
2042
+
2043
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#82
2044
+ class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
2045
+
2046
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23
2047
+ class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
2048
+
2049
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87
2050
+ module Regexp::Expression::UnicodeProperty::Symbol; end
2051
+
2052
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#90
2053
+ class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2054
+
2055
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88
2056
+ class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
2057
+
2058
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92
2059
+ class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2060
+
2061
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#91
2062
+ class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2063
+
2064
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#93
2065
+ class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2066
+
2067
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#94
2068
+ class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
2069
+
2070
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24
2071
+ class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
2072
+
2073
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25
2074
+ class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
2075
+
2076
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27
2077
+ class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
2078
+
2079
+ # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26
2080
+ class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
2081
+
2082
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#11
2083
+ class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
2084
+ # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#42
2085
+ def human_name; end
2086
+
2087
+ # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#12
2088
+ def merge(exp); end
2089
+ end
2090
+
2091
+ # A very thin wrapper around the scanner that breaks quantified literal runs,
2092
+ # collects emitted tokens into an array, calculates their nesting depth, and
2093
+ # normalizes tokens for the parser, and checks if they are implemented by the
2094
+ # given syntax flavor.
2095
+ #
2096
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#5
2097
+ class Regexp::Lexer
2098
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#71
2099
+ def emit(token); end
2100
+
2101
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#20
2102
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2103
+
2104
+ private
2105
+
2106
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#91
2107
+ def ascend(type, token); end
2108
+
2109
+ # Returns the value of attribute block.
2110
+ #
2111
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2112
+ def block; end
2113
+
2114
+ # Sets the attribute block
2115
+ #
2116
+ # @param value the value to set the attribute block to.
2117
+ #
2118
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2119
+ def block=(_arg0); end
2120
+
2121
+ # if a codepoint list is followed by a quantifier, that quantifier applies
2122
+ # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc'
2123
+ # c.f. #break_literal.
2124
+ #
2125
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#143
2126
+ def break_codepoint_list(token); end
2127
+
2128
+ # called by scan to break a literal run that is longer than one character
2129
+ # into two separate tokens when it is followed by a quantifier
2130
+ #
2131
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#123
2132
+ def break_literal(token); end
2133
+
2134
+ # Returns the value of attribute collect_tokens.
2135
+ #
2136
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2137
+ def collect_tokens; end
2138
+
2139
+ # Sets the attribute collect_tokens
2140
+ #
2141
+ # @param value the value to set the attribute collect_tokens to.
2142
+ #
2143
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2144
+ def collect_tokens=(_arg0); end
2145
+
2146
+ # Returns the value of attribute conditional_nesting.
2147
+ #
2148
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2149
+ def conditional_nesting; end
2150
+
2151
+ # Sets the attribute conditional_nesting
2152
+ #
2153
+ # @param value the value to set the attribute conditional_nesting to.
2154
+ #
2155
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2156
+ def conditional_nesting=(_arg0); end
2157
+
2158
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#106
2159
+ def descend(type, token); end
2160
+
2161
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#162
2162
+ def merge_condition(current, last); end
2163
+
2164
+ # Returns the value of attribute nesting.
2165
+ #
2166
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2167
+ def nesting; end
2168
+
2169
+ # Sets the attribute nesting
2170
+ #
2171
+ # @param value the value to set the attribute nesting to.
2172
+ #
2173
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2174
+ def nesting=(_arg0); end
2175
+
2176
+ # Returns the value of attribute preprev_token.
2177
+ #
2178
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2179
+ def preprev_token; end
2180
+
2181
+ # Sets the attribute preprev_token
2182
+ #
2183
+ # @param value the value to set the attribute preprev_token to.
2184
+ #
2185
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2186
+ def preprev_token=(_arg0); end
2187
+
2188
+ # Returns the value of attribute prev_token.
2189
+ #
2190
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2191
+ def prev_token; end
2192
+
2193
+ # Sets the attribute prev_token
2194
+ #
2195
+ # @param value the value to set the attribute prev_token to.
2196
+ #
2197
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2198
+ def prev_token=(_arg0); end
2199
+
2200
+ # Returns the value of attribute set_nesting.
2201
+ #
2202
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2203
+ def set_nesting; end
2204
+
2205
+ # Sets the attribute set_nesting
2206
+ #
2207
+ # @param value the value to set the attribute set_nesting to.
2208
+ #
2209
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2210
+ def set_nesting=(_arg0); end
2211
+
2212
+ # Returns the value of attribute shift.
2213
+ #
2214
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2215
+ def shift; end
2216
+
2217
+ # Sets the attribute shift
2218
+ #
2219
+ # @param value the value to set the attribute shift to.
2220
+ #
2221
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2222
+ def shift=(_arg0); end
2223
+
2224
+ # Returns the value of attribute tokens.
2225
+ #
2226
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2227
+ def tokens; end
2228
+
2229
+ # Sets the attribute tokens
2230
+ #
2231
+ # @param value the value to set the attribute tokens to.
2232
+ #
2233
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#87
2234
+ def tokens=(_arg0); end
2235
+
2236
+ class << self
2237
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#16
2238
+ def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2239
+
2240
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#16
2241
+ def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2242
+ end
2243
+ end
2244
+
2245
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#12
2246
+ Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
2247
+
2248
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#14
2249
+ Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array)
2250
+
2251
+ # source://regexp_parser//lib/regexp_parser/lexer.rb#7
2252
+ Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
2253
+
2254
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#1
2255
+ class Regexp::MatchLength
2256
+ include ::Enumerable
2257
+
2258
+ # @return [MatchLength] a new instance of MatchLength
2259
+ #
2260
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#9
2261
+ def initialize(exp, opts = T.unsafe(nil)); end
2262
+
2263
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#24
2264
+ def each(opts = T.unsafe(nil)); end
2265
+
2266
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#35
2267
+ def endless_each; end
2268
+
2269
+ # @return [Boolean]
2270
+ #
2271
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#44
2272
+ def fixed?; end
2273
+
2274
+ # @return [Boolean]
2275
+ #
2276
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#40
2277
+ def include?(length); end
2278
+
2279
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#60
2280
+ def inspect; end
2281
+
2282
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#52
2283
+ def max; end
2284
+
2285
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#48
2286
+ def min; end
2287
+
2288
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#56
2289
+ def minmax; end
2290
+
2291
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#65
2292
+ def to_re; end
2293
+
2294
+ private
2295
+
2296
+ # Returns the value of attribute base_max.
2297
+ #
2298
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2299
+ def base_max; end
2300
+
2301
+ # Sets the attribute base_max
2302
+ #
2303
+ # @param value the value to set the attribute base_max to.
2304
+ #
2305
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2306
+ def base_max=(_arg0); end
2307
+
2308
+ # Returns the value of attribute base_min.
2309
+ #
2310
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2311
+ def base_min; end
2312
+
2313
+ # Sets the attribute base_min
2314
+ #
2315
+ # @param value the value to set the attribute base_min to.
2316
+ #
2317
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2318
+ def base_min=(_arg0); end
2319
+
2320
+ # Returns the value of attribute exp_class.
2321
+ #
2322
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2323
+ def exp_class; end
2324
+
2325
+ # Sets the attribute exp_class
2326
+ #
2327
+ # @param value the value to set the attribute exp_class to.
2328
+ #
2329
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2330
+ def exp_class=(_arg0); end
2331
+
2332
+ # Returns the value of attribute max_rep.
2333
+ #
2334
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2335
+ def max_rep; end
2336
+
2337
+ # Sets the attribute max_rep
2338
+ #
2339
+ # @param value the value to set the attribute max_rep to.
2340
+ #
2341
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2342
+ def max_rep=(_arg0); end
2343
+
2344
+ # Returns the value of attribute min_rep.
2345
+ #
2346
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2347
+ def min_rep; end
2348
+
2349
+ # Sets the attribute min_rep
2350
+ #
2351
+ # @param value the value to set the attribute min_rep to.
2352
+ #
2353
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2354
+ def min_rep=(_arg0); end
2355
+
2356
+ # Returns the value of attribute reify.
2357
+ #
2358
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2359
+ def reify; end
2360
+
2361
+ # Sets the attribute reify
2362
+ #
2363
+ # @param value the value to set the attribute reify to.
2364
+ #
2365
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
2366
+ def reify=(_arg0); end
2367
+
2368
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#74
2369
+ def test_regexp; end
2370
+
2371
+ class << self
2372
+ # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#4
2373
+ def of(obj); end
2374
+ end
2375
+ end
2376
+
2377
+ # source://regexp_parser//lib/regexp_parser/version.rb#2
2378
+ class Regexp::Parser
2379
+ include ::Regexp::Expression
2380
+
2381
+ # source://regexp_parser//lib/regexp_parser/parser.rb#25
2382
+ def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2383
+
2384
+ private
2385
+
2386
+ # source://regexp_parser//lib/regexp_parser/parser.rb#574
2387
+ def active_opts; end
2388
+
2389
+ # source://regexp_parser//lib/regexp_parser/parser.rb#99
2390
+ def anchor(token); end
2391
+
2392
+ # source://regexp_parser//lib/regexp_parser/parser.rb#262
2393
+ def assign_effective_number(exp); end
2394
+
2395
+ # Assigns referenced expressions to referring expressions, e.g. if there is
2396
+ # an instance of Backreference::Number, its #referenced_expression is set to
2397
+ # the instance of Group::Capture that it refers to via its number.
2398
+ #
2399
+ # source://regexp_parser//lib/regexp_parser/parser.rb#581
2400
+ def assign_referenced_expressions; end
2401
+
2402
+ # source://regexp_parser//lib/regexp_parser/parser.rb#227
2403
+ def backref(token); end
2404
+
2405
+ # source://regexp_parser//lib/regexp_parser/parser.rb#202
2406
+ def captured_group_count_at_level; end
2407
+
2408
+ # Returns the value of attribute captured_group_counts.
2409
+ #
2410
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2411
+ def captured_group_counts; end
2412
+
2413
+ # Sets the attribute captured_group_counts
2414
+ #
2415
+ # @param value the value to set the attribute captured_group_counts to.
2416
+ #
2417
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2418
+ def captured_group_counts=(_arg0); end
2419
+
2420
+ # source://regexp_parser//lib/regexp_parser/parser.rb#570
2421
+ def close_completed_character_set_range; end
2422
+
2423
+ # source://regexp_parser//lib/regexp_parser/parser.rb#210
2424
+ def close_group; end
2425
+
2426
+ # source://regexp_parser//lib/regexp_parser/parser.rb#538
2427
+ def close_set; end
2428
+
2429
+ # source://regexp_parser//lib/regexp_parser/parser.rb#269
2430
+ def conditional(token); end
2431
+
2432
+ # Returns the value of attribute conditional_nesting.
2433
+ #
2434
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2435
+ def conditional_nesting; end
2436
+
2437
+ # Sets the attribute conditional_nesting
2438
+ #
2439
+ # @param value the value to set the attribute conditional_nesting to.
2440
+ #
2441
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2442
+ def conditional_nesting=(_arg0); end
2443
+
2444
+ # source://regexp_parser//lib/regexp_parser/parser.rb#206
2445
+ def count_captured_group; end
2446
+
2447
+ # @yield [node]
2448
+ #
2449
+ # source://regexp_parser//lib/regexp_parser/parser.rb#216
2450
+ def decrease_nesting; end
2451
+
2452
+ # source://regexp_parser//lib/regexp_parser/parser.rb#305
2453
+ def escape(token); end
2454
+
2455
+ # source://regexp_parser//lib/regexp_parser/parser.rb#60
2456
+ def extract_options(input, options); end
2457
+
2458
+ # source://regexp_parser//lib/regexp_parser/parser.rb#349
2459
+ def free_space(token); end
2460
+
2461
+ # source://regexp_parser//lib/regexp_parser/parser.rb#114
2462
+ def group(token); end
2463
+
2464
+ # source://regexp_parser//lib/regexp_parser/parser.rb#509
2465
+ def increase_group_level(exp); end
2466
+
2467
+ # source://regexp_parser//lib/regexp_parser/parser.rb#549
2468
+ def intersection(token); end
2469
+
2470
+ # source://regexp_parser//lib/regexp_parser/parser.rb#360
2471
+ def keep(token); end
2472
+
2473
+ # source://regexp_parser//lib/regexp_parser/parser.rb#364
2474
+ def literal(token); end
2475
+
2476
+ # source://regexp_parser//lib/regexp_parser/parser.rb#368
2477
+ def meta(token); end
2478
+
2479
+ # source://regexp_parser//lib/regexp_parser/parser.rb#534
2480
+ def negate_set; end
2481
+
2482
+ # source://regexp_parser//lib/regexp_parser/parser.rb#299
2483
+ def nest(exp); end
2484
+
2485
+ # source://regexp_parser//lib/regexp_parser/parser.rb#294
2486
+ def nest_conditional(exp); end
2487
+
2488
+ # Returns the value of attribute nesting.
2489
+ #
2490
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2491
+ def nesting; end
2492
+
2493
+ # Sets the attribute nesting
2494
+ #
2495
+ # @param value the value to set the attribute nesting to.
2496
+ #
2497
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2498
+ def nesting=(_arg0); end
2499
+
2500
+ # Returns the value of attribute node.
2501
+ #
2502
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2503
+ def node; end
2504
+
2505
+ # Sets the attribute node
2506
+ #
2507
+ # @param value the value to set the attribute node to.
2508
+ #
2509
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2510
+ def node=(_arg0); end
2511
+
2512
+ # source://regexp_parser//lib/regexp_parser/parser.rb#165
2513
+ def open_group(token); end
2514
+
2515
+ # source://regexp_parser//lib/regexp_parser/parser.rb#527
2516
+ def open_set(token); end
2517
+
2518
+ # source://regexp_parser//lib/regexp_parser/parser.rb#130
2519
+ def options_group(token); end
2520
+
2521
+ # Returns the value of attribute options_stack.
2522
+ #
2523
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2524
+ def options_stack; end
2525
+
2526
+ # Sets the attribute options_stack
2527
+ #
2528
+ # @param value the value to set the attribute options_stack to.
2529
+ #
2530
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2531
+ def options_stack=(_arg0); end
2532
+
2533
+ # source://regexp_parser//lib/regexp_parser/parser.rb#76
2534
+ def parse_token(token); end
2535
+
2536
+ # source://regexp_parser//lib/regexp_parser/parser.rb#390
2537
+ def posixclass(token); end
2538
+
2539
+ # source://regexp_parser//lib/regexp_parser/parser.rb#397
2540
+ def property(token); end
2541
+
2542
+ # source://regexp_parser//lib/regexp_parser/parser.rb#479
2543
+ def quantifier(token); end
2544
+
2545
+ # source://regexp_parser//lib/regexp_parser/parser.rb#542
2546
+ def range(token); end
2547
+
2548
+ # Returns the value of attribute root.
2549
+ #
2550
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2551
+ def root; end
2552
+
2553
+ # Sets the attribute root
2554
+ #
2555
+ # @param value the value to set the attribute root to.
2556
+ #
2557
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2558
+ def root=(_arg0); end
2559
+
2560
+ # source://regexp_parser//lib/regexp_parser/parser.rb#379
2561
+ def sequence_operation(klass, token); end
2562
+
2563
+ # source://regexp_parser//lib/regexp_parser/parser.rb#515
2564
+ def set(token); end
2565
+
2566
+ # Returns the value of attribute switching_options.
2567
+ #
2568
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2569
+ def switching_options; end
2570
+
2571
+ # Sets the attribute switching_options
2572
+ #
2573
+ # @param value the value to set the attribute switching_options to.
2574
+ #
2575
+ # source://regexp_parser//lib/regexp_parser/parser.rb#56
2576
+ def switching_options=(_arg0); end
2577
+
2578
+ # source://regexp_parser//lib/regexp_parser/parser.rb#198
2579
+ def total_captured_group_count; end
2580
+
2581
+ # source://regexp_parser//lib/regexp_parser/parser.rb#553
2582
+ def type(token); end
2583
+
2584
+ class << self
2585
+ # source://regexp_parser//lib/regexp_parser/parser.rb#21
2586
+ def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
2587
+ end
2588
+ end
2589
+
2590
+ # source://regexp_parser//lib/regexp_parser/parser.rb#128
2591
+ Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
2592
+
2593
+ # base class for all gem-specific errors
2594
+ #
2595
+ # source://regexp_parser//lib/regexp_parser/error.rb#3
2596
+ class Regexp::Parser::Error < ::StandardError; end
2597
+
2598
+ # source://regexp_parser//lib/regexp_parser/parser.rb#127
2599
+ Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
2600
+
2601
+ # source://regexp_parser//lib/regexp_parser/parser.rb#7
2602
+ class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
2603
+
2604
+ # source://regexp_parser//lib/regexp_parser/parser.rb#394
2605
+ Regexp::Parser::UP = Regexp::Expression::UnicodeProperty
2606
+
2607
+ # source://regexp_parser//lib/regexp_parser/parser.rb#395
2608
+ Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
2609
+
2610
+ # source://regexp_parser//lib/regexp_parser/parser.rb#15
2611
+ class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
2612
+ # @return [UnknownTokenError] a new instance of UnknownTokenError
2613
+ #
2614
+ # source://regexp_parser//lib/regexp_parser/parser.rb#16
2615
+ def initialize(type, token); end
2616
+ end
2617
+
2618
+ # source://regexp_parser//lib/regexp_parser/parser.rb#9
2619
+ class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
2620
+ # @return [UnknownTokenTypeError] a new instance of UnknownTokenTypeError
2621
+ #
2622
+ # source://regexp_parser//lib/regexp_parser/parser.rb#10
2623
+ def initialize(type, token); end
2624
+ end
2625
+
2626
+ # source://regexp_parser//lib/regexp_parser/version.rb#3
2627
+ Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
2628
+
2629
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#3
2630
+ class Regexp::Scanner
2631
+ # Emits an array with the details of the scanned pattern
2632
+ #
2633
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2363
2634
+ def emit(type, token, text); end
2635
+
2636
+ # only public for #||= to work on ruby <= 2.5
2637
+ #
2638
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2388
2639
+ def literal_run; end
2640
+
2641
+ # only public for #||= to work on ruby <= 2.5
2642
+ #
2643
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2388
2644
+ def literal_run=(_arg0); end
2645
+
2646
+ # @raise [PrematureEndError]
2647
+ #
2648
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#24
2649
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2650
+
2651
+ private
2652
+
2653
+ # Appends one or more characters to the literal buffer, to be emitted later
2654
+ # by a call to emit_literal.
2655
+ #
2656
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2425
2657
+ def append_literal(data, ts, te); end
2658
+
2659
+ # Returns the value of attribute block.
2660
+ #
2661
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2662
+ def block; end
2663
+
2664
+ # Sets the attribute block
2665
+ #
2666
+ # @param value the value to set the attribute block to.
2667
+ #
2668
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2669
+ def block=(_arg0); end
2670
+
2671
+ # Returns the value of attribute char_pos.
2672
+ #
2673
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2674
+ def char_pos; end
2675
+
2676
+ # Sets the attribute char_pos
2677
+ #
2678
+ # @param value the value to set the attribute char_pos to.
2679
+ #
2680
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2681
+ def char_pos=(_arg0); end
2682
+
2683
+ # Returns the value of attribute collect_tokens.
2684
+ #
2685
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2686
+ def collect_tokens; end
2687
+
2688
+ # Sets the attribute collect_tokens
2689
+ #
2690
+ # @param value the value to set the attribute collect_tokens to.
2691
+ #
2692
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2693
+ def collect_tokens=(_arg0); end
2694
+
2695
+ # Returns the value of attribute conditional_stack.
2696
+ #
2697
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2698
+ def conditional_stack; end
2699
+
2700
+ # Sets the attribute conditional_stack
2701
+ #
2702
+ # @param value the value to set the attribute conditional_stack to.
2703
+ #
2704
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2705
+ def conditional_stack=(_arg0); end
2706
+
2707
+ # Copy from ts to te from data as text
2708
+ #
2709
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2419
2710
+ def copy(data, ts, te); end
2711
+
2712
+ # Emits the literal run collected by calls to the append_literal method.
2713
+ #
2714
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2430
2715
+ def emit_literal; end
2716
+
2717
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2465
2718
+ def emit_meta_control_sequence(data, ts, te, token); end
2719
+
2720
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2436
2721
+ def emit_options(text); end
2722
+
2723
+ # Returns the value of attribute free_spacing.
2724
+ #
2725
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2726
+ def free_spacing; end
2727
+
2728
+ # Sets the attribute free_spacing
2729
+ #
2730
+ # @param value the value to set the attribute free_spacing to.
2731
+ #
2732
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2733
+ def free_spacing=(_arg0); end
2734
+
2735
+ # @return [Boolean]
2736
+ #
2737
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2398
2738
+ def free_spacing?(input_object, options); end
2739
+
2740
+ # Returns the value of attribute group_depth.
2741
+ #
2742
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2743
+ def group_depth; end
2744
+
2745
+ # Sets the attribute group_depth
2746
+ #
2747
+ # @param value the value to set the attribute group_depth to.
2748
+ #
2749
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2750
+ def group_depth=(_arg0); end
2751
+
2752
+ # @return [Boolean]
2753
+ #
2754
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2410
2755
+ def in_group?; end
2756
+
2757
+ # @return [Boolean]
2758
+ #
2759
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2414
2760
+ def in_set?; end
2761
+
2762
+ # Returns the value of attribute prev_token.
2763
+ #
2764
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2765
+ def prev_token; end
2766
+
2767
+ # Sets the attribute prev_token
2768
+ #
2769
+ # @param value the value to set the attribute prev_token to.
2770
+ #
2771
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2772
+ def prev_token=(_arg0); end
2773
+
2774
+ # Returns the value of attribute set_depth.
2775
+ #
2776
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2777
+ def set_depth; end
2778
+
2779
+ # Sets the attribute set_depth
2780
+ #
2781
+ # @param value the value to set the attribute set_depth to.
2782
+ #
2783
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2784
+ def set_depth=(_arg0); end
2785
+
2786
+ # Returns the value of attribute spacing_stack.
2787
+ #
2788
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2789
+ def spacing_stack; end
2790
+
2791
+ # Sets the attribute spacing_stack
2792
+ #
2793
+ # @param value the value to set the attribute spacing_stack to.
2794
+ #
2795
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2796
+ def spacing_stack=(_arg0); end
2797
+
2798
+ # Returns the value of attribute tokens.
2799
+ #
2800
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2801
+ def tokens; end
2802
+
2803
+ # Sets the attribute tokens
2804
+ #
2805
+ # @param value the value to set the attribute tokens to.
2806
+ #
2807
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
2808
+ def tokens=(_arg0); end
2809
+
2810
+ class << self
2811
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2349
2812
+ def long_prop_map; end
2813
+
2814
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2353
2815
+ def parse_prop_map(name); end
2816
+
2817
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2357
2818
+ def posix_classes; end
2819
+
2820
+ # Scans the given regular expression text, or Regexp object and collects the
2821
+ # emitted token into an array that gets returned at the end. If a block is
2822
+ # given, it gets called for each emitted token.
2823
+ #
2824
+ # This method may raise errors if a syntax error is encountered.
2825
+ # --------------------------------------------------------------------------
2826
+ #
2827
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#20
2828
+ def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
2829
+
2830
+ # lazy-load property maps when first needed
2831
+ #
2832
+ # source://regexp_parser//lib/regexp_parser/scanner.rb#2345
2833
+ def short_prop_map; end
2834
+ end
2835
+ end
2836
+
2837
+ # Invalid back reference. Used for name a number refs/calls.
2838
+ #
2839
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#44
2840
+ class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
2841
+ # @return [InvalidBackrefError] a new instance of InvalidBackrefError
2842
+ #
2843
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#45
2844
+ def initialize(what, reason); end
2845
+ end
2846
+
2847
+ # Invalid group. Used for named groups.
2848
+ #
2849
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#29
2850
+ class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
2851
+ # @return [InvalidGroupError] a new instance of InvalidGroupError
2852
+ #
2853
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#30
2854
+ def initialize(what, reason); end
2855
+ end
2856
+
2857
+ # Invalid groupOption. Used for inline options.
2858
+ # TODO: should become InvalidGroupOptionError in v3.0.0 for consistency
2859
+ #
2860
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#37
2861
+ class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
2862
+ # @return [InvalidGroupOption] a new instance of InvalidGroupOption
2863
+ #
2864
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#38
2865
+ def initialize(option, text); end
2866
+ end
2867
+
2868
+ # Invalid sequence format. Used for escape sequences, mainly.
2869
+ #
2870
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#22
2871
+ class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
2872
+ # @return [InvalidSequenceError] a new instance of InvalidSequenceError
2873
+ #
2874
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#23
2875
+ def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
2876
+ end
2877
+
2878
+ # Unexpected end of pattern
2879
+ #
2880
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#3
2881
+ class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
2882
+ # @return [PrematureEndError] a new instance of PrematureEndError
2883
+ #
2884
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#4
2885
+ def initialize(where = T.unsafe(nil)); end
2886
+ end
2887
+
2888
+ # General scanner error (catch all)
2889
+ #
2890
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#5
2891
+ class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
2892
+
2893
+ # The POSIX class name was not recognized by the scanner.
2894
+ #
2895
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#58
2896
+ class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
2897
+ # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError
2898
+ #
2899
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#59
2900
+ def initialize(text, _); end
2901
+ end
2902
+
2903
+ # The property name was not recognized by the scanner.
2904
+ #
2905
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#51
2906
+ class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
2907
+ # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError
2908
+ #
2909
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#52
2910
+ def initialize(name, _); end
2911
+ end
2912
+
2913
+ # Base for all scanner validation errors
2914
+ #
2915
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#4
2916
+ class Regexp::Scanner::ValidationError < ::Regexp::Scanner::ScannerError
2917
+ class << self
2918
+ # Centralizes and unifies the handling of validation related errors.
2919
+ #
2920
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#5
2921
+ def for(type, problem, reason = T.unsafe(nil)); end
2922
+
2923
+ # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#9
2924
+ def types; end
2925
+ end
2926
+ end
2927
+
2928
+ # After loading all the tokens the map is full. Extract all tokens and types
2929
+ # into the All and Types constants.
2930
+ #
2931
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#3
2932
+ module Regexp::Syntax
2933
+ private
2934
+
2935
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2936
+ def comparable(name); end
2937
+
2938
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2939
+ def const_missing(const_name); end
2940
+
2941
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2942
+ def fallback_version_class(version); end
2943
+
2944
+ # Returns the syntax specification class for the given syntax
2945
+ # version name. The special names 'any' and '*' return Syntax::Any.
2946
+ #
2947
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22
2948
+ def for(name); end
2949
+
2950
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2951
+ def new(name); end
2952
+
2953
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2954
+ def specified_versions; end
2955
+
2956
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
2957
+ def supported?(name); end
2958
+
2959
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2960
+ def version_class(version); end
2961
+
2962
+ class << self
2963
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
2964
+ def comparable(name); end
2965
+
2966
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
2967
+ def const_missing(const_name); end
2968
+
2969
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
2970
+ def fallback_version_class(version); end
2971
+
2972
+ # Returns the syntax specification class for the given syntax
2973
+ # version name. The special names 'any' and '*' return Syntax::Any.
2974
+ #
2975
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22
2976
+ def for(name); end
2977
+
2978
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
2979
+ def new(name); end
2980
+
2981
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
2982
+ def specified_versions; end
2983
+
2984
+ # @return [Boolean]
2985
+ #
2986
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
2987
+ def supported?(name); end
2988
+
2989
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
2990
+ def version_class(version); end
2991
+ end
2992
+ end
2993
+
2994
+ # A syntax that always returns true, passing all tokens as implemented. This
2995
+ # is useful during development, testing, and should be useful for some types
2996
+ # of transformations as well.
2997
+ #
2998
+ # source://regexp_parser//lib/regexp_parser/syntax/any.rb#5
2999
+ class Regexp::Syntax::Any < ::Regexp::Syntax::Base
3000
+ class << self
3001
+ # @return [Boolean]
3002
+ #
3003
+ # source://regexp_parser//lib/regexp_parser/syntax/any.rb#8
3004
+ def implements?(_type, _token); end
3005
+ end
3006
+ end
3007
+
3008
+ # A lookup map of supported types and tokens in a given syntax
3009
+ #
3010
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#9
3011
+ class Regexp::Syntax::Base
3012
+ include ::Regexp::Syntax::Token
3013
+
3014
+ # TODO: drop this backwards compatibility code in v3.0.0, do `private :new`
3015
+ #
3016
+ # @return [Base] a new instance of Base
3017
+ #
3018
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#99
3019
+ def initialize; end
3020
+
3021
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#104
3022
+ def method_missing(name, *args); end
3023
+
3024
+ private
3025
+
3026
+ # @return [Boolean]
3027
+ #
3028
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#115
3029
+ def respond_to_missing?(name, include_private = T.unsafe(nil)); end
3030
+
3031
+ class << self
3032
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#46
3033
+ def added_features; end
3034
+
3035
+ # @raise [NotImplementedError]
3036
+ #
3037
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40
3038
+ def check!(type, token); end
3039
+
3040
+ # @return [Boolean]
3041
+ #
3042
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31
3043
+ def check?(type, token); end
3044
+
3045
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#26
3046
+ def excludes(type, tokens); end
3047
+
3048
+ # Returns the value of attribute features.
3049
+ #
3050
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13
3051
+ def features; end
3052
+
3053
+ # Sets the attribute features
3054
+ #
3055
+ # @param value the value to set the attribute features to.
3056
+ #
3057
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13
3058
+ def features=(_arg0); end
3059
+
3060
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#36
3061
+ def implementations(type); end
3062
+
3063
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#21
3064
+ def implements(type, tokens); end
3065
+
3066
+ # @raise [NotImplementedError]
3067
+ #
3068
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40
3069
+ def implements!(type, token); end
3070
+
3071
+ # @return [Boolean]
3072
+ #
3073
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31
3074
+ def implements?(type, token); end
3075
+
3076
+ # automatically inherit features through the syntax class hierarchy
3077
+ #
3078
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#16
3079
+ def inherited(subclass); end
3080
+
3081
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#54
3082
+ def normalize(type, token); end
3083
+
3084
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#74
3085
+ def normalize_backref(type, token); end
3086
+
3087
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#65
3088
+ def normalize_group(type, token); end
3089
+
3090
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#50
3091
+ def removed_features; end
3092
+ end
3093
+ end
3094
+
3095
+ # source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8
3096
+ Regexp::Syntax::CURRENT = Regexp::Syntax::V3_1_0
3097
+
3098
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6
3099
+ class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
3100
+ # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError
3101
+ #
3102
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#7
3103
+ def initialize(name); end
3104
+ end
3105
+
3106
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#2
3107
+ class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
3108
+ # @return [NotImplementedError] a new instance of NotImplementedError
3109
+ #
3110
+ # source://regexp_parser//lib/regexp_parser/syntax/base.rb#3
3111
+ def initialize(syntax, type, token); end
3112
+ end
3113
+
3114
+ # source://regexp_parser//lib/regexp_parser/syntax.rb#4
3115
+ class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
3116
+
3117
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#3
3118
+ module Regexp::Syntax::Token; end
3119
+
3120
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#42
3121
+ Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
3122
+
3123
+ # alias for symmetry between Token::* and Expression::*
3124
+ #
3125
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#15
3126
+ module Regexp::Syntax::Token::Alternation; end
3127
+
3128
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#16
3129
+ Regexp::Syntax::Token::Alternation::All = T.let(T.unsafe(nil), Array)
3130
+
3131
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#17
3132
+ Regexp::Syntax::Token::Alternation::Type = T.let(T.unsafe(nil), Symbol)
3133
+
3134
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#3
3135
+ module Regexp::Syntax::Token::Anchor; end
3136
+
3137
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#9
3138
+ Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array)
3139
+
3140
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#4
3141
+ Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array)
3142
+
3143
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#5
3144
+ Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array)
3145
+
3146
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#7
3147
+ Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array)
3148
+
3149
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#6
3150
+ Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
3151
+
3152
+ # source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#10
3153
+ Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
3154
+
3155
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#3
3156
+ module Regexp::Syntax::Token::Assertion; end
3157
+
3158
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#7
3159
+ Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array)
3160
+
3161
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#4
3162
+ Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array)
3163
+
3164
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#5
3165
+ Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
3166
+
3167
+ # source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#8
3168
+ Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
3169
+
3170
+ # alias for symmetry between token symbol and Expression class name
3171
+ #
3172
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#31
3173
+ Regexp::Syntax::Token::Backref = Regexp::Syntax::Token::Backreference
3174
+
3175
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#3
3176
+ module Regexp::Syntax::Token::Backreference; end
3177
+
3178
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#15
3179
+ Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array)
3180
+
3181
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#7
3182
+ Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array)
3183
+
3184
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#6
3185
+ Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array)
3186
+
3187
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#5
3188
+ Regexp::Syntax::Token::Backreference::NumberRef = T.let(T.unsafe(nil), Array)
3189
+
3190
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#4
3191
+ Regexp::Syntax::Token::Backreference::Plain = T.let(T.unsafe(nil), Array)
3192
+
3193
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#9
3194
+ Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array)
3195
+
3196
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#16
3197
+ Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol)
3198
+
3199
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#11
3200
+ Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array)
3201
+
3202
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#13
3203
+ Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array)
3204
+
3205
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#3
3206
+ module Regexp::Syntax::Token::CharacterSet; end
3207
+
3208
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#7
3209
+ Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array)
3210
+
3211
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#4
3212
+ Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array)
3213
+
3214
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#5
3215
+ Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
3216
+
3217
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#8
3218
+ Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
3219
+
3220
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#3
3221
+ module Regexp::Syntax::Token::CharacterType; end
3222
+
3223
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#10
3224
+ Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array)
3225
+
3226
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#4
3227
+ Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array)
3228
+
3229
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#8
3230
+ Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array)
3231
+
3232
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#5
3233
+ Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array)
3234
+
3235
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#6
3236
+ Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
3237
+
3238
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#11
3239
+ Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
3240
+
3241
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#3
3242
+ module Regexp::Syntax::Token::Conditional; end
3243
+
3244
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#9
3245
+ Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array)
3246
+
3247
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#6
3248
+ Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array)
3249
+
3250
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#4
3251
+ Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array)
3252
+
3253
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#7
3254
+ Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
3255
+
3256
+ # source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#11
3257
+ Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
3258
+
3259
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#3
3260
+ module Regexp::Syntax::Token::Escape; end
3261
+
3262
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#8
3263
+ Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array)
3264
+
3265
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#24
3266
+ Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array)
3267
+
3268
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4
3269
+ Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array)
3270
+
3271
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#6
3272
+ Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array)
3273
+
3274
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#20
3275
+ Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array)
3276
+
3277
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#13
3278
+ Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array)
3279
+
3280
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#22
3281
+ Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array)
3282
+
3283
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#25
3284
+ Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
3285
+
3286
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#11
3287
+ Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
3288
+
3289
+ # alias for symmetry between Token::* and Expression::*
3290
+ #
3291
+ # source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#31
3292
+ Regexp::Syntax::Token::EscapeSequence = Regexp::Syntax::Token::Escape
3293
+
3294
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#11
3295
+ module Regexp::Syntax::Token::FreeSpace; end
3296
+
3297
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#12
3298
+ Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
3299
+
3300
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#13
3301
+ Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
3302
+
3303
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#3
3304
+ module Regexp::Syntax::Token::Group; end
3305
+
3306
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#17
3307
+ Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array)
3308
+
3309
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#8
3310
+ Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array)
3311
+
3312
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#4
3313
+ Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array)
3314
+
3315
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#10
3316
+ Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array)
3317
+
3318
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#5
3319
+ Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array)
3320
+
3321
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#7
3322
+ Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array)
3323
+
3324
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#9
3325
+ Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array)
3326
+
3327
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#18
3328
+ Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol)
3329
+
3330
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#12
3331
+ Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
3332
+
3333
+ # source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#15
3334
+ Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
3335
+
3336
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#3
3337
+ module Regexp::Syntax::Token::Keep; end
3338
+
3339
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#6
3340
+ Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array)
3341
+
3342
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#4
3343
+ Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
3344
+
3345
+ # source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#7
3346
+ Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
3347
+
3348
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#6
3349
+ module Regexp::Syntax::Token::Literal; end
3350
+
3351
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#7
3352
+ Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array)
3353
+
3354
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#8
3355
+ Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
3356
+
3357
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#4
3358
+ Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
3359
+
3360
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#3
3361
+ module Regexp::Syntax::Token::Meta; end
3362
+
3363
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8
3364
+ Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array)
3365
+
3366
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#5
3367
+ Regexp::Syntax::Token::Meta::Alternation = T.let(T.unsafe(nil), Array)
3368
+
3369
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#4
3370
+ Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array)
3371
+
3372
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#6
3373
+ Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
3374
+
3375
+ # source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#9
3376
+ Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
3377
+
3378
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#3
3379
+ module Regexp::Syntax::Token::PosixClass; end
3380
+
3381
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#9
3382
+ Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array)
3383
+
3384
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#7
3385
+ Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array)
3386
+
3387
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#11
3388
+ Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol)
3389
+
3390
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#4
3391
+ Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
3392
+
3393
+ # source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#10
3394
+ Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
3395
+
3396
+ # alias for symmetry between token symbol and Token module name
3397
+ #
3398
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#749
3399
+ Regexp::Syntax::Token::Property = Regexp::Syntax::Token::UnicodeProperty
3400
+
3401
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#3
3402
+ module Regexp::Syntax::Token::Quantifier; end
3403
+
3404
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#29
3405
+ Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array)
3406
+
3407
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#4
3408
+ Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array)
3409
+
3410
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#22
3411
+ Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array)
3412
+
3413
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#26
3414
+ Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array)
3415
+
3416
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#24
3417
+ Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array)
3418
+
3419
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#23
3420
+ Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array)
3421
+
3422
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#16
3423
+ Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array)
3424
+
3425
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#10
3426
+ Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array)
3427
+
3428
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#30
3429
+ Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
3430
+
3431
+ # source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#28
3432
+ Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array)
3433
+
3434
+ # alias for symmetry between token symbol and Token module name
3435
+ #
3436
+ # source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#14
3437
+ Regexp::Syntax::Token::Set = Regexp::Syntax::Token::CharacterSet
3438
+
3439
+ # Type is the same as Backreference so keeping it here, for now.
3440
+ #
3441
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#20
3442
+ module Regexp::Syntax::Token::SubexpressionCall; end
3443
+
3444
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#24
3445
+ Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array)
3446
+
3447
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#21
3448
+ Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array)
3449
+
3450
+ # source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#22
3451
+ Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
3452
+
3453
+ # source://regexp_parser//lib/regexp_parser/syntax/token.rb#43
3454
+ Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
3455
+
3456
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#3
3457
+ module Regexp::Syntax::Token::UnicodeProperty; end
3458
+
3459
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#64
3460
+ Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array)
3461
+
3462
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#40
3463
+ Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array)
3464
+
3465
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#44
3466
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array)
3467
+
3468
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#46
3469
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array)
3470
+
3471
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#48
3472
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array)
3473
+
3474
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#50
3475
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array)
3476
+
3477
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#52
3478
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array)
3479
+
3480
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#54
3481
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array)
3482
+
3483
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#56
3484
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array)
3485
+
3486
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#58
3487
+ Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array)
3488
+
3489
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#60
3490
+ Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array)
3491
+
3492
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#62
3493
+ Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array)
3494
+
3495
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#739
3496
+ Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
3497
+
3498
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#13
3499
+ module Regexp::Syntax::Token::UnicodeProperty::Category; end
3500
+
3501
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#36
3502
+ Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array)
3503
+
3504
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#33
3505
+ Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array)
3506
+
3507
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#14
3508
+ Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array)
3509
+
3510
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#17
3511
+ Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array)
3512
+
3513
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#20
3514
+ Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array)
3515
+
3516
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#23
3517
+ Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array)
3518
+
3519
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#30
3520
+ Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array)
3521
+
3522
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#27
3523
+ Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array)
3524
+
3525
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#6
3526
+ Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array)
3527
+
3528
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#9
3529
+ Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array)
3530
+
3531
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#133
3532
+ Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array)
3533
+
3534
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#66
3535
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array)
3536
+
3537
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#120
3538
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array)
3539
+
3540
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#125
3541
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array)
3542
+
3543
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#129
3544
+ Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array)
3545
+
3546
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#724
3547
+ Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array)
3548
+
3549
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#694
3550
+ Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array)
3551
+
3552
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#702
3553
+ Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_6_0 = T.let(T.unsafe(nil), Array)
3554
+
3555
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#722
3556
+ Regexp::Syntax::Token::UnicodeProperty::Enumerated = T.let(T.unsafe(nil), Array)
3557
+
3558
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706
3559
+ Regexp::Syntax::Token::UnicodeProperty::Enumerated_V2_4_0 = T.let(T.unsafe(nil), Array)
3560
+
3561
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#742
3562
+ Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol)
3563
+
3564
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#11
3565
+ Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array)
3566
+
3567
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#332
3568
+ Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array)
3569
+
3570
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#135
3571
+ Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array)
3572
+
3573
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#231
3574
+ Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array)
3575
+
3576
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#237
3577
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array)
3578
+
3579
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#247
3580
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array)
3581
+
3582
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#273
3583
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array)
3584
+
3585
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#282
3586
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array)
3587
+
3588
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#291
3589
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array)
3590
+
3591
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#298
3592
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array)
3593
+
3594
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#308
3595
+ Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array)
3596
+
3597
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#315
3598
+ Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Array)
3599
+
3600
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#322
3601
+ Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array)
3602
+
3603
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#741
3604
+ Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol)
3605
+
3606
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#692
3607
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array)
3608
+
3609
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#334
3610
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array)
3611
+
3612
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#433
3613
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array)
3614
+
3615
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#561
3616
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array)
3617
+
3618
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#596
3619
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array)
3620
+
3621
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#609
3622
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array)
3623
+
3624
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#623
3625
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array)
3626
+
3627
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#633
3628
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array)
3629
+
3630
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#647
3631
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array)
3632
+
3633
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#659
3634
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array)
3635
+
3636
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#670
3637
+ Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array)
3638
+
3639
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#726
3640
+ Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array)
3641
+
3642
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#727
3643
+ Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array)
3644
+
3645
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#728
3646
+ Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array)
3647
+
3648
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#729
3649
+ Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array)
3650
+
3651
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#730
3652
+ Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array)
3653
+
3654
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#731
3655
+ Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array)
3656
+
3657
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#732
3658
+ Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array)
3659
+
3660
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#733
3661
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array)
3662
+
3663
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#734
3664
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array)
3665
+
3666
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#735
3667
+ Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array)
3668
+
3669
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#736
3670
+ Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array)
3671
+
3672
+ # source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#737
3673
+ Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array)
3674
+
3675
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#12
3676
+ class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
3677
+ # @return [UnknownSyntaxNameError] a new instance of UnknownSyntaxNameError
3678
+ #
3679
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#13
3680
+ def initialize(name); end
3681
+ end
3682
+
3683
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.8.6.rb#1
3684
+ class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end
3685
+
3686
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.1.rb#1
3687
+ class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end
3688
+
3689
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.3.rb#1
3690
+ class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end
3691
+
3692
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.0.0.rb#1
3693
+ class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end
3694
+
3695
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.2.0.rb#1
3696
+ class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end
3697
+
3698
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.3.0.rb#1
3699
+ class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end
3700
+
3701
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.0.rb#1
3702
+ class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end
3703
+
3704
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.1.rb#1
3705
+ class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end
3706
+
3707
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.5.0.rb#1
3708
+ class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end
3709
+
3710
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.0.rb#1
3711
+ class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end
3712
+
3713
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.2.rb#1
3714
+ class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end
3715
+
3716
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.3.rb#1
3717
+ class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end
3718
+
3719
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.1.0.rb#1
3720
+ class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end
3721
+
3722
+ # source://regexp_parser//lib/regexp_parser/syntax/versions/3.2.0.rb#1
3723
+ class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end
3724
+
3725
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#4
3726
+ Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp)
3727
+
3728
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#2
3729
+ Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String)
3730
+
3731
+ # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#3
3732
+ Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
3733
+
3734
+ # source://regexp_parser//lib/regexp_parser/token.rb#2
3735
+ Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
3736
+
3737
+ # source://regexp_parser//lib/regexp_parser/token.rb#13
3738
+ class Regexp::Token < ::Struct
3739
+ def conditional_level; end
3740
+ def conditional_level=(_); end
3741
+
3742
+ # source://regexp_parser//lib/regexp_parser/token.rb#20
3743
+ def length; end
3744
+
3745
+ def level; end
3746
+ def level=(_); end
3747
+
3748
+ # Returns the value of attribute next.
3749
+ #
3750
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3751
+ def next; end
3752
+
3753
+ # Sets the attribute next
3754
+ #
3755
+ # @param value the value to set the attribute next to.
3756
+ #
3757
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3758
+ def next=(_arg0); end
3759
+
3760
+ # source://regexp_parser//lib/regexp_parser/token.rb#16
3761
+ def offset; end
3762
+
3763
+ # Returns the value of attribute previous.
3764
+ #
3765
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3766
+ def previous; end
3767
+
3768
+ # Sets the attribute previous
3769
+ #
3770
+ # @param value the value to set the attribute previous to.
3771
+ #
3772
+ # source://regexp_parser//lib/regexp_parser/token.rb#14
3773
+ def previous=(_arg0); end
3774
+
3775
+ def set_level; end
3776
+ def set_level=(_); end
3777
+ def te; end
3778
+ def te=(_); end
3779
+ def text; end
3780
+ def text=(_); end
3781
+ def token; end
3782
+ def token=(_); end
3783
+ def ts; end
3784
+ def ts=(_); end
3785
+ def type; end
3786
+ def type=(_); end
3787
+
3788
+ class << self
3789
+ def [](*_arg0); end
3790
+ def inspect; end
3791
+ def keyword_init?; end
3792
+ def members; end
3793
+ def new(*_arg0); end
3794
+ end
3795
+ end