hierarchical_config 0.11 → 0.13

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