esquema 0.1.1 → 0.1.2

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