categoria 0.1.0.pre.beta0

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