@temperlang/std 0.0.3 → 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/config.js +26 -3
  2. package/config.js.map +1 -1
  3. package/package.json +5 -2
  4. package/regex.js +928 -833
  5. package/regex.js.map +1 -1
  6. package/regex__preface.js +3 -2
  7. package/regex__preface.js.map +1 -1
  8. package/testing.js +53 -49
  9. package/testing.js.map +1 -1
  10. package/testing__preface.js +3 -2
  11. package/testing__preface.js.map +1 -1
package/regex.js CHANGED
@@ -1,533 +1,600 @@
1
1
  import {
2
- InterfaceType as InterfaceType_51, listify as listify_52, compiledRegexCompileFormatted as compiledRegexCompileFormatted_53, compiledRegexCompiledFoundIn as compiledRegexCompiledFoundIn_54, compiledRegexCompiledFind as compiledRegexCompiledFind_55, listJoin as listJoin_56, genericEq as genericEq_57, listBuilderAdd as listBuilderAdd_58, regexFormatterPushCodeTo as regexFormatterPushCodeTo_59, regexFormatterAdjustCodeSet as regexFormatterAdjustCodeSet_60, genericLt as genericLt_61, listGet as listGet_62, genericNe as genericNe_63, genericGt as genericGt_64, strCat as strCat_10, stringCodePoints as stringCodePoints_8, intToString as intToString_9, requireInstanceOf as requireInstanceOf__254, noResultException as noResultException__256, requireIsSafeInteger as requireIsSafeInteger__352
2
+ InterfaceType as InterfaceType_1, listify as listify_2, compiledRegexCompileFormatted as compiledRegexCompileFormatted_3, compiledRegexCompiledFound as compiledRegexCompiledFound_4, compiledRegexCompiledFind as compiledRegexCompiledFind_5, compiledRegexCompiledReplace as compiledRegexCompiledReplace_6, listJoin as listJoin_7, eqGeneric as eqGeneric_8, listBuilderAdd as listBuilderAdd_9, strCat as strCat_10, regexFormatterPushCodeTo as regexFormatterPushCodeTo_11, stringCodePoints as stringCodePoints_12, regexFormatterAdjustCodeSet as regexFormatterAdjustCodeSet_13, ltGeneric as ltGeneric_14, listGet as listGet_15, eqGeneric as eqGeneric_16, intToString as intToString_17, neGeneric as neGeneric_18, gtGeneric as gtGeneric_19, requireInstanceOf as requireInstanceOf__182, noResultException as noResultException__184, requireIsSafeInteger as requireIsSafeInteger__274
3
3
  } from "@temperlang/core";
4
- export function Regex(x_65) {
5
- return x_65 instanceof Regex_66;
6
- };
7
- export function CodePart(x_67) {
8
- return x_67 instanceof CodePart_68;
9
- };
10
- export function Special(x_69) {
11
- return x_69 instanceof Special_70;
12
- };
13
- export function SpecialSet(x_71) {
14
- return x_71 instanceof SpecialSet_72;
15
- };
16
- function methodCompiled73() {
17
- let return_74;
18
- let t_75 = CompiledRegex(this);
19
- return_74 = t_75;
20
- return return_74;
4
+ function methodCompiled20() {
5
+ let return_21;
6
+ let t_22 = new CompiledRegex(this);
7
+ return_21 = t_22;
8
+ return return_21;
21
9
  }
22
- function methodFoundIn76(text_77) {
23
- let return_78;
24
- let t_79 = this.compiled();
25
- let t_80 = t_79.foundIn(text_77);
26
- return_78 = t_80;
27
- return return_78;
10
+ function methodFound23(text_24) {
11
+ let return_25;
12
+ let t_26 = this.compiled();
13
+ let t_27 = t_26.found(text_24);
14
+ return_25 = t_27;
15
+ return return_25;
28
16
  }
29
- function methodFind81(text_82) {
30
- let return_83;
31
- let t_84;
32
- let t_85 = this.compiled();
17
+ function methodFind28(text_29) {
18
+ let return_30;
19
+ let t_31;
20
+ let t_32 = this.compiled();
33
21
  {
34
- t_84 = t_85.find(text_82);
35
- return_83 = t_84;
22
+ t_31 = t_32.find(text_29);
23
+ return_30 = t_31;
36
24
  }
37
- return return_83;
25
+ return return_30;
38
26
  }
39
- const Regex_66 = new InterfaceType_51("Regex", [["m", "compiled", methodCompiled73], ["m", "foundIn", methodFoundIn76], ["m", "find", methodFind81]], [], 1);
40
- export function Capture(...args_86) {
41
- return new Capture_87(...args_86);
42
- };
43
- class Capture_87 {
44
- #name_88;
45
- #item_89;
46
- constructor(name_90, item_91) {
47
- let return_92;
48
- return_92 = void 0;
49
- this.#name_88 = name_90;
50
- this.#item_89 = item_91;
27
+ function methodReplace33(text_34, format_35) {
28
+ let return_36;
29
+ let t_37 = this.compiled();
30
+ let t_38 = t_37.replace(text_34, format_35);
31
+ return_36 = t_38;
32
+ return return_36;
33
+ }
34
+ /**
35
+ * @typedef {{
36
+ * compiled: () => CompiledRegex, found: (text_24: string) => boolean, find: (text_29: string) => "Unsupported type: Map\u003cString, Group\u003e | NoResult", replace: (text_34: string, format_35: (arg0: Map<string, Group>) => string) => string
37
+ * }}
38
+ * Regex
39
+ */
40
+ export const Regex = new InterfaceType_1("Regex", [["m", "compiled", methodCompiled20], ["m", "found", methodFound23], ["m", "find", methodFind28], ["m", "replace", methodReplace33]], [], 1);
41
+ ;
42
+ export class Capture {
43
+ /** @type {string} */
44
+ #name_39;
45
+ /** @type {Regex} */
46
+ #item_40;
47
+ /**
48
+ * @param {string} name_41
49
+ * @param {Regex} item_42
50
+ */
51
+ constructor(name_41, item_42) {
52
+ let return_43;
53
+ return_43 = void 0;
54
+ this.#name_39 = name_41;
55
+ this.#item_40 = item_42;
51
56
  return;
52
57
  }
58
+ /** @returns {string} */
53
59
  get name() {
54
- let return_94;
55
- return_94 = this.#name_88;
56
- return return_94;
60
+ let return_45;
61
+ return_45 = this.#name_39;
62
+ return return_45;
57
63
  }
64
+ /** @returns {Regex} */
58
65
  get item() {
59
- let return_96;
60
- return_96 = this.#item_89;
61
- return return_96;
66
+ let return_47;
67
+ return_47 = this.#item_40;
68
+ return return_47;
62
69
  }
63
- }
64
- Regex_66.implementedBy(Capture_87);
65
- const CodePart_68 = new InterfaceType_51("CodePart", [], [Regex_66], 2);
66
- export function CodePoints(...args_97) {
67
- return new CodePoints_98(...args_97);
68
70
  };
69
- class CodePoints_98 {
70
- #value_99;
71
- constructor(value_100) {
72
- let return_101;
73
- return_101 = void 0;
74
- this.#value_99 = value_100;
71
+ Regex.implementedBy(Capture);
72
+ /**
73
+ * @typedef {{}}
74
+ * CodePart
75
+ */
76
+ export const CodePart = new InterfaceType_1("CodePart", [], [Regex], 2);
77
+ ;
78
+ export class CodePoints {
79
+ /** @type {string} */
80
+ #value_48;
81
+ /** @param {string} value_49 */
82
+ constructor(value_49) {
83
+ let return_50;
84
+ return_50 = void 0;
85
+ this.#value_48 = value_49;
75
86
  return;
76
87
  }
88
+ /** @returns {string} */
77
89
  get value() {
78
- let return_103;
79
- return_103 = this.#value_99;
80
- return return_103;
90
+ let return_52;
91
+ return_52 = this.#value_48;
92
+ return return_52;
81
93
  }
82
- }
83
- CodePart_68.implementedBy(CodePoints_98);
84
- const Special_70 = new InterfaceType_51("Special", [], [Regex_66], 2);
85
- const SpecialSet_72 = new InterfaceType_51("SpecialSet", [], [CodePart_68, Special_70], 3);
86
- export function CodeRange(...args_104) {
87
- return new CodeRange_105(...args_104);
88
94
  };
89
- class CodeRange_105 {
90
- #min_106;
91
- #max_107;
92
- constructor(min_108, max_109) {
93
- let return_110;
94
- return_110 = void 0;
95
- this.#min_106 = min_108;
96
- this.#max_107 = max_109;
95
+ CodePart.implementedBy(CodePoints);
96
+ /**
97
+ * @typedef {{}}
98
+ * Special
99
+ */
100
+ export const Special = new InterfaceType_1("Special", [], [Regex], 2);
101
+ ;
102
+ /**
103
+ * @typedef {{}}
104
+ * SpecialSet
105
+ */
106
+ export const SpecialSet = new InterfaceType_1("SpecialSet", [], [CodePart, Special], 3);
107
+ ;
108
+ export class CodeRange {
109
+ /** @type {number} */
110
+ #min_53;
111
+ /** @type {number} */
112
+ #max_54;
113
+ /**
114
+ * @param {number} min_55
115
+ * @param {number} max_56
116
+ */
117
+ constructor(min_55, max_56) {
118
+ let return_57;
119
+ return_57 = void 0;
120
+ this.#min_53 = min_55;
121
+ this.#max_54 = max_56;
97
122
  return;
98
123
  }
124
+ /** @returns {number} */
99
125
  get min() {
100
- let return_112;
101
- return_112 = this.#min_106;
102
- return return_112;
126
+ let return_59;
127
+ return_59 = this.#min_53;
128
+ return return_59;
103
129
  }
130
+ /** @returns {number} */
104
131
  get max() {
105
- let return_114;
106
- return_114 = this.#max_107;
107
- return return_114;
132
+ let return_61;
133
+ return_61 = this.#max_54;
134
+ return return_61;
108
135
  }
109
- }
110
- CodePart_68.implementedBy(CodeRange_105);
111
- export function CodeSet(...args_115) {
112
- return new CodeSet_116(...args_115);
113
136
  };
114
- class CodeSet_116 {
115
- #items_117;
116
- #negated_118;
117
- constructor(items_119, negated_120) {
118
- let return_121;
119
- return_121 = void 0;
120
- if (!(negated_120 !== void 0)) {
121
- negated_120 = false;
137
+ CodePart.implementedBy(CodeRange);
138
+ export class CodeSet {
139
+ /** @type {Array<CodePart>} */
140
+ #items_62;
141
+ /** @type {boolean} */
142
+ #negated_63;
143
+ /**
144
+ * @param {Array<CodePart>} items_64
145
+ * @param {boolean} negated_65
146
+ */
147
+ constructor(items_64, negated_65) {
148
+ let return_66;
149
+ return_66 = void 0;
150
+ if (!(negated_65 !== void 0)) {
151
+ negated_65 = false;
122
152
  }
123
- this.#items_117 = items_119;
124
- this.#negated_118 = negated_120;
153
+ this.#items_62 = items_64;
154
+ this.#negated_63 = negated_65;
125
155
  return;
126
156
  }
157
+ /** @returns {Array<CodePart>} */
127
158
  get items() {
128
- let return_123;
129
- return_123 = this.#items_117;
130
- return return_123;
159
+ let return_68;
160
+ return_68 = this.#items_62;
161
+ return return_68;
131
162
  }
163
+ /** @returns {boolean} */
132
164
  get negated() {
133
- let return_125;
134
- return_125 = this.#negated_118;
135
- return return_125;
165
+ let return_70;
166
+ return_70 = this.#negated_63;
167
+ return return_70;
136
168
  }
137
- }
138
- Regex_66.implementedBy(CodeSet_116);
139
- export function Or(...args_126) {
140
- return new Or_127(...args_126);
141
169
  };
142
- class Or_127 {
143
- #items_128;
144
- constructor(items_129) {
145
- let return_130;
146
- return_130 = void 0;
147
- this.#items_128 = items_129;
170
+ Regex.implementedBy(CodeSet);
171
+ export class Or {
172
+ /** @type {Array<Regex>} */
173
+ #items_71;
174
+ /** @param {Array<Regex>} items_72 */
175
+ constructor(items_72) {
176
+ let return_73;
177
+ return_73 = void 0;
178
+ this.#items_71 = items_72;
148
179
  return;
149
180
  }
181
+ /** @returns {Array<Regex>} */
150
182
  get items() {
151
- let return_132;
152
- return_132 = this.#items_128;
153
- return return_132;
183
+ let return_75;
184
+ return_75 = this.#items_71;
185
+ return return_75;
154
186
  }
155
- }
156
- Regex_66.implementedBy(Or_127);
157
- export function Repeat(...args_133) {
158
- return new Repeat_134(...args_133);
159
187
  };
160
- class Repeat_134 {
161
- #item_135;
162
- #min_136;
163
- #max_137;
164
- #reluctant_138;
165
- constructor(item_139, min_140, max_141, reluctant_142) {
166
- let return_143;
167
- return_143 = void 0;
168
- if (!(reluctant_142 !== void 0)) {
169
- reluctant_142 = false;
188
+ Regex.implementedBy(Or);
189
+ export class Repeat {
190
+ /** @type {Regex} */
191
+ #item_76;
192
+ /** @type {number} */
193
+ #min_77;
194
+ /** @type {"Unsupported type: Int | Null"} */
195
+ #max_78;
196
+ /** @type {boolean} */
197
+ #reluctant_79;
198
+ /**
199
+ * @param {Regex} item_80
200
+ * @param {number} min_81
201
+ * @param {"Unsupported type: Int | Null"} max_82
202
+ * @param {boolean} reluctant_83
203
+ */
204
+ constructor(item_80, min_81, max_82, reluctant_83) {
205
+ let return_84;
206
+ return_84 = void 0;
207
+ if (!(reluctant_83 !== void 0)) {
208
+ reluctant_83 = false;
170
209
  }
171
- this.#item_135 = item_139;
172
- this.#min_136 = min_140;
173
- this.#max_137 = max_141;
174
- this.#reluctant_138 = reluctant_142;
210
+ this.#item_76 = item_80;
211
+ this.#min_77 = min_81;
212
+ this.#max_78 = max_82;
213
+ this.#reluctant_79 = reluctant_83;
175
214
  return;
176
215
  }
216
+ /** @returns {Regex} */
177
217
  get item() {
178
- let return_145;
179
- return_145 = this.#item_135;
180
- return return_145;
218
+ let return_86;
219
+ return_86 = this.#item_76;
220
+ return return_86;
181
221
  }
222
+ /** @returns {number} */
182
223
  get min() {
183
- let return_147;
184
- return_147 = this.#min_136;
185
- return return_147;
224
+ let return_88;
225
+ return_88 = this.#min_77;
226
+ return return_88;
186
227
  }
228
+ /** @returns {"Unsupported type: Int | Null"} */
187
229
  get max() {
188
- let return_149;
189
- return_149 = this.#max_137;
190
- return return_149;
230
+ let return_90;
231
+ return_90 = this.#max_78;
232
+ return return_90;
191
233
  }
234
+ /** @returns {boolean} */
192
235
  get reluctant() {
193
- let return_151;
194
- return_151 = this.#reluctant_138;
195
- return return_151;
236
+ let return_92;
237
+ return_92 = this.#reluctant_79;
238
+ return return_92;
196
239
  }
197
- }
198
- Regex_66.implementedBy(Repeat_134);
199
- export function Sequence(...args_152) {
200
- return new Sequence_153(...args_152);
201
240
  };
202
- class Sequence_153 {
203
- #items_154;
204
- constructor(items_155) {
205
- let return_156;
206
- return_156 = void 0;
207
- this.#items_154 = items_155;
241
+ Regex.implementedBy(Repeat);
242
+ export class Sequence {
243
+ /** @type {Array<Regex>} */
244
+ #items_93;
245
+ /** @param {Array<Regex>} items_94 */
246
+ constructor(items_94) {
247
+ let return_95;
248
+ return_95 = void 0;
249
+ this.#items_93 = items_94;
208
250
  return;
209
251
  }
252
+ /** @returns {Array<Regex>} */
210
253
  get items() {
211
- let return_158;
212
- return_158 = this.#items_154;
213
- return return_158;
254
+ let return_97;
255
+ return_97 = this.#items_93;
256
+ return return_97;
214
257
  }
215
- }
216
- Regex_66.implementedBy(Sequence_153);
217
- export function Match(...args_159) {
218
- return new Match_160(...args_159);
219
258
  };
220
- class Match_160 {
221
- #groups_161;
222
- constructor(groups_162) {
223
- let return_163;
224
- return_163 = void 0;
225
- this.#groups_161 = groups_162;
226
- return;
227
- }
228
- get groups() {
229
- let return_165;
230
- return_165 = this.#groups_161;
231
- return return_165;
232
- }
233
- }
234
- export function Group(...args_166) {
235
- return new Group_167(...args_166);
236
- };
237
- class Group_167 {
238
- #name_168;
239
- #value_169;
240
- #codePointsBegin_170;
241
- constructor(name_171, value_172, codePointsBegin_173) {
242
- let return_174;
243
- return_174 = void 0;
244
- this.#name_168 = name_171;
245
- this.#value_169 = value_172;
246
- this.#codePointsBegin_170 = codePointsBegin_173;
259
+ Regex.implementedBy(Sequence);
260
+ export class Group {
261
+ /** @type {string} */
262
+ #name_98;
263
+ /** @type {string} */
264
+ #value_99;
265
+ /** @type {number} */
266
+ #codePointsBegin_100;
267
+ /**
268
+ * @param {string} name_101
269
+ * @param {string} value_102
270
+ * @param {number} codePointsBegin_103
271
+ */
272
+ constructor(name_101, value_102, codePointsBegin_103) {
273
+ let return_104;
274
+ return_104 = void 0;
275
+ this.#name_98 = name_101;
276
+ this.#value_99 = value_102;
277
+ this.#codePointsBegin_100 = codePointsBegin_103;
247
278
  return;
248
279
  }
280
+ /** @returns {string} */
249
281
  get name() {
250
- let return_176;
251
- return_176 = this.#name_168;
252
- return return_176;
282
+ let return_106;
283
+ return_106 = this.#name_98;
284
+ return return_106;
253
285
  }
286
+ /** @returns {string} */
254
287
  get value() {
255
- let return_178;
256
- return_178 = this.#value_169;
257
- return return_178;
288
+ let return_108;
289
+ return_108 = this.#value_99;
290
+ return return_108;
258
291
  }
292
+ /** @returns {number} */
259
293
  get codePointsBegin() {
260
- let return_180;
261
- return_180 = this.#codePointsBegin_170;
262
- return return_180;
294
+ let return_110;
295
+ return_110 = this.#codePointsBegin_100;
296
+ return return_110;
263
297
  }
264
- }
265
- function RegexRefs_181(...args_182) {
266
- return new RegexRefs_183(...args_182);
267
- }
268
- class RegexRefs_183 {
269
- #codePoints_184;
270
- #match_185;
271
- #orObject_186;
272
- constructor(codePoints_187, match_188, orObject_189) {
273
- let return_190;
274
- let t_191;
275
- let t_192;
276
- let t_193;
277
- let t_194;
278
- return_190 = void 0;
279
- if (!(codePoints_187 !== void 0)) {
280
- t_191 = CodePoints("");
281
- codePoints_187 = t_191;
298
+ };
299
+ class RegexRefs_111 {
300
+ /** @type {CodePoints} */
301
+ #codePoints_112;
302
+ /** @type {Group} */
303
+ #group_113;
304
+ /** @type {Or} */
305
+ #orObject_114;
306
+ /**
307
+ * @param {CodePoints} codePoints_115
308
+ * @param {Group} group_116
309
+ * @param {Or} orObject_117
310
+ */
311
+ constructor(codePoints_115, group_116, orObject_117) {
312
+ let return_118;
313
+ let t_119;
314
+ let t_120;
315
+ let t_121;
316
+ return_118 = void 0;
317
+ if (!(codePoints_115 !== void 0)) {
318
+ t_119 = new CodePoints("");
319
+ codePoints_115 = t_119;
282
320
  }
283
- if (!(match_188 !== void 0)) {
284
- t_192 = Group("", "", 0);
285
- t_193 = Match(listify_52(t_192));
286
- match_188 = t_193;
321
+ if (!(group_116 !== void 0)) {
322
+ t_120 = new Group("", "", 0);
323
+ group_116 = t_120;
287
324
  }
288
- if (!(orObject_189 !== void 0)) {
289
- t_194 = Or(listify_52());
290
- orObject_189 = t_194;
325
+ if (!(orObject_117 !== void 0)) {
326
+ t_121 = new Or(listify_2());
327
+ orObject_117 = t_121;
291
328
  }
292
- this.#codePoints_184 = codePoints_187;
293
- this.#match_185 = match_188;
294
- this.#orObject_186 = orObject_189;
329
+ this.#codePoints_112 = codePoints_115;
330
+ this.#group_113 = group_116;
331
+ this.#orObject_114 = orObject_117;
295
332
  return;
296
333
  }
334
+ /** @returns {CodePoints} */
297
335
  get codePoints() {
298
- let return_196;
299
- return_196 = this.#codePoints_184;
300
- return return_196;
336
+ let return_123;
337
+ return_123 = this.#codePoints_112;
338
+ return return_123;
301
339
  }
302
- get match() {
303
- let return_198;
304
- return_198 = this.#match_185;
305
- return return_198;
340
+ /** @returns {Group} */
341
+ get group() {
342
+ let return_125;
343
+ return_125 = this.#group_113;
344
+ return return_125;
306
345
  }
346
+ /** @returns {Or} */
307
347
  get orObject() {
308
- let return_200;
309
- return_200 = this.#orObject_186;
310
- return return_200;
348
+ let return_127;
349
+ return_127 = this.#orObject_114;
350
+ return return_127;
311
351
  }
312
352
  }
313
- export function CompiledRegex(...args_201) {
314
- return new CompiledRegex_202(...args_201);
315
- };
316
- class CompiledRegex_202 {
317
- #data_203;
318
- constructor(data_204) {
319
- let return_205;
320
- return_205 = void 0;
321
- this.#data_203 = data_204;
322
- let t_206 = this.format();
323
- let t_207 = compiledRegexCompileFormatted_53(this, t_206);
324
- this.#compiled_208 = t_207;
353
+ export class CompiledRegex {
354
+ /** @type {Regex} */
355
+ #data_128;
356
+ /** @param {Regex} data_129 */
357
+ constructor(data_129) {
358
+ let return_130;
359
+ return_130 = void 0;
360
+ this.#data_128 = data_129;
361
+ let t_131 = this.format();
362
+ let t_132 = compiledRegexCompileFormatted_3(this, t_131);
363
+ this.#compiled_133 = t_132;
325
364
  return;
326
365
  }
327
- foundIn(text_210) {
328
- let return_211;
329
- let t_212 = compiledRegexCompiledFoundIn_54(this, this.#compiled_208, text_210);
330
- return_211 = t_212;
331
- return return_211;
366
+ /**
367
+ * @param {string} text_135
368
+ * @returns {boolean}
369
+ */
370
+ found(text_135) {
371
+ let return_136;
372
+ let t_137 = compiledRegexCompiledFound_4(this, this.#compiled_133, text_135);
373
+ return_136 = t_137;
374
+ return return_136;
332
375
  }
333
- find(text_214) {
334
- let return_215;
335
- let t_216;
376
+ /**
377
+ * @param {string} text_139
378
+ * @returns {"Unsupported type: Map\u003cString, Group\u003e | NoResult"}
379
+ */
380
+ find(text_139) {
381
+ let return_140;
382
+ let t_141;
336
383
  {
337
- t_216 = compiledRegexCompiledFind_55(this, this.#compiled_208, text_214, regexRefs_217);
338
- return_215 = t_216;
384
+ t_141 = compiledRegexCompiledFind_5(this, this.#compiled_133, text_139, regexRefs_142);
385
+ return_140 = t_141;
339
386
  }
340
- return return_215;
387
+ return return_140;
341
388
  }
342
- #compiled_208;
389
+ /**
390
+ * @param {string} text_144
391
+ * @param {(arg0: Map<string, Group>) => string} format_145
392
+ * @returns {string}
393
+ */
394
+ replace(text_144, format_145) {
395
+ let return_146;
396
+ let t_147 = compiledRegexCompiledReplace_6(this, this.#compiled_133, text_144, format_145, regexRefs_142);
397
+ return_146 = t_147;
398
+ return return_146;
399
+ }
400
+ /** @type {unknown} */
401
+ #compiled_133;
402
+ /** @returns {string} */
343
403
  format() {
344
- let return_219;
345
- let t_220 = RegexFormatter_221();
346
- let t_222 = t_220.format(this.#data_203);
347
- return_219 = t_222;
348
- return return_219;
404
+ let return_149;
405
+ let t_150 = new RegexFormatter_151();
406
+ let t_152 = t_150.format(this.#data_128);
407
+ return_149 = t_152;
408
+ return return_149;
349
409
  }
410
+ /** @returns {Regex} */
350
411
  get data() {
351
- let return_224;
352
- return_224 = this.#data_203;
353
- return return_224;
412
+ let return_154;
413
+ return_154 = this.#data_128;
414
+ return return_154;
354
415
  }
355
- }
356
- function RegexFormatter_221(...args_225) {
357
- return new RegexFormatter_226(...args_225);
358
- }
359
- class RegexFormatter_226 {
360
- #out_227;
361
- format(regex_229) {
362
- let return_230;
363
- this.pushRegex(regex_229);
364
- let t_231 = this.#out_227;
365
- function fn_232(x_233) {
366
- let return_234;
367
- return_234 = x_233;
368
- return return_234;
416
+ };
417
+ class RegexFormatter_151 {
418
+ /** @type {Array<string>} */
419
+ #out_155;
420
+ /**
421
+ * @param {Regex} regex_157
422
+ * @returns {string}
423
+ */
424
+ format(regex_157) {
425
+ let return_158;
426
+ this.pushRegex(regex_157);
427
+ let t_159 = this.#out_155;
428
+ function fn_160(x_161) {
429
+ let return_162;
430
+ return_162 = x_161;
431
+ return return_162;
369
432
  }
370
- let t_235 = fn_232;
371
- let t_236 = listJoin_56(t_231, "", t_235);
372
- return_230 = t_236;
373
- return return_230;
433
+ let t_163 = fn_160;
434
+ let t_164 = listJoin_7(t_159, "", t_163);
435
+ return_158 = t_164;
436
+ return return_158;
374
437
  }
375
- pushRegex(regex_238) {
376
- let return_239;
377
- return_239 = void 0;
378
- let t_240;
379
- let t_241;
380
- let t_242;
381
- let t_243;
382
- let t_244;
383
- let t_245;
384
- let t_246;
385
- let t_247;
386
- let t_248;
387
- let t_249;
388
- let t_250;
389
- let t_251;
390
- let t_252;
391
- let t_253;
438
+ /**
439
+ * @param {Regex} regex_166
440
+ * @returns {void}
441
+ */
442
+ pushRegex(regex_166) {
443
+ let return_167;
444
+ return_167 = void 0;
445
+ let t_168;
446
+ let t_169;
447
+ let t_170;
448
+ let t_171;
449
+ let t_172;
450
+ let t_173;
451
+ let t_174;
452
+ let t_175;
453
+ let t_176;
454
+ let t_177;
455
+ let t_178;
456
+ let t_179;
457
+ let t_180;
458
+ let t_181;
392
459
  try {
393
- requireInstanceOf__254(regex_238, Capture_87);
394
- t_240 = true;
460
+ requireInstanceOf__182(regex_166, Capture);
461
+ t_168 = true;
395
462
  } catch {
396
- t_240 = false;
463
+ t_168 = false;
397
464
  }
398
- s_255: {
399
- if (t_240) {
465
+ s__1217_183: {
466
+ if (t_168) {
400
467
  try {
401
- t_241 = requireInstanceOf__254(regex_238, Capture_87);
468
+ t_169 = requireInstanceOf__182(regex_166, Capture);
402
469
  } catch {
403
- break s_255;
470
+ break s__1217_183;
404
471
  }
405
- this.pushCapture(t_241);
472
+ this.pushCapture(t_169);
406
473
  } else {
407
474
  try {
408
- requireInstanceOf__254(regex_238, CodePoints_98);
409
- t_242 = true;
475
+ requireInstanceOf__182(regex_166, CodePoints);
476
+ t_170 = true;
410
477
  } catch {
411
- t_242 = false;
478
+ t_170 = false;
412
479
  }
413
- if (t_242) {
480
+ if (t_170) {
414
481
  try {
415
- t_243 = requireInstanceOf__254(regex_238, CodePoints_98);
482
+ t_171 = requireInstanceOf__182(regex_166, CodePoints);
416
483
  } catch {
417
- break s_255;
484
+ break s__1217_183;
418
485
  }
419
- this.pushCodePoints(t_243, false);
486
+ this.pushCodePoints(t_171, false);
420
487
  } else {
421
488
  try {
422
- requireInstanceOf__254(regex_238, CodeRange_105);
423
- t_244 = true;
489
+ requireInstanceOf__182(regex_166, CodeRange);
490
+ t_172 = true;
424
491
  } catch {
425
- t_244 = false;
492
+ t_172 = false;
426
493
  }
427
- if (t_244) {
494
+ if (t_172) {
428
495
  try {
429
- t_245 = requireInstanceOf__254(regex_238, CodeRange_105);
496
+ t_173 = requireInstanceOf__182(regex_166, CodeRange);
430
497
  } catch {
431
- break s_255;
498
+ break s__1217_183;
432
499
  }
433
- this.pushCodeRange(t_245);
500
+ this.pushCodeRange(t_173);
434
501
  } else {
435
502
  try {
436
- requireInstanceOf__254(regex_238, CodeSet_116);
437
- t_246 = true;
503
+ requireInstanceOf__182(regex_166, CodeSet);
504
+ t_174 = true;
438
505
  } catch {
439
- t_246 = false;
506
+ t_174 = false;
440
507
  }
441
- if (t_246) {
508
+ if (t_174) {
442
509
  try {
443
- t_247 = requireInstanceOf__254(regex_238, CodeSet_116);
510
+ t_175 = requireInstanceOf__182(regex_166, CodeSet);
444
511
  } catch {
445
- break s_255;
512
+ break s__1217_183;
446
513
  }
447
- this.pushCodeSet(t_247);
514
+ this.pushCodeSet(t_175);
448
515
  } else {
449
516
  try {
450
- requireInstanceOf__254(regex_238, Or_127);
451
- t_248 = true;
517
+ requireInstanceOf__182(regex_166, Or);
518
+ t_176 = true;
452
519
  } catch {
453
- t_248 = false;
520
+ t_176 = false;
454
521
  }
455
- if (t_248) {
522
+ if (t_176) {
456
523
  try {
457
- t_249 = requireInstanceOf__254(regex_238, Or_127);
524
+ t_177 = requireInstanceOf__182(regex_166, Or);
458
525
  } catch {
459
- break s_255;
526
+ break s__1217_183;
460
527
  }
461
- this.pushOr(t_249);
528
+ this.pushOr(t_177);
462
529
  } else {
463
530
  try {
464
- requireInstanceOf__254(regex_238, Repeat_134);
465
- t_250 = true;
531
+ requireInstanceOf__182(regex_166, Repeat);
532
+ t_178 = true;
466
533
  } catch {
467
- t_250 = false;
534
+ t_178 = false;
468
535
  }
469
- if (t_250) {
536
+ if (t_178) {
470
537
  try {
471
- t_251 = requireInstanceOf__254(regex_238, Repeat_134);
538
+ t_179 = requireInstanceOf__182(regex_166, Repeat);
472
539
  } catch {
473
- break s_255;
540
+ break s__1217_183;
474
541
  }
475
- this.pushRepeat(t_251);
542
+ this.pushRepeat(t_179);
476
543
  } else {
477
544
  try {
478
- requireInstanceOf__254(regex_238, Sequence_153);
479
- t_252 = true;
545
+ requireInstanceOf__182(regex_166, Sequence);
546
+ t_180 = true;
480
547
  } catch {
481
- t_252 = false;
548
+ t_180 = false;
482
549
  }
483
- if (t_252) {
550
+ if (t_180) {
484
551
  try {
485
- t_253 = requireInstanceOf__254(regex_238, Sequence_153);
552
+ t_181 = requireInstanceOf__182(regex_166, Sequence);
486
553
  } catch {
487
- break s_255;
554
+ break s__1217_183;
488
555
  }
489
- this.pushSequence(t_253);
490
- } else if (genericEq_57(regex_238, Begin)) {
556
+ this.pushSequence(t_181);
557
+ } else if (eqGeneric_8(regex_166, Begin)) {
491
558
  try {
492
- listBuilderAdd_58(this.#out_227, "^");
559
+ listBuilderAdd_9(this.#out_155, "^");
493
560
  } catch {
494
- break s_255;
561
+ break s__1217_183;
495
562
  }
496
- } else if (genericEq_57(regex_238, Dot)) {
563
+ } else if (eqGeneric_8(regex_166, Dot)) {
497
564
  try {
498
- listBuilderAdd_58(this.#out_227, ".");
565
+ listBuilderAdd_9(this.#out_155, ".");
499
566
  } catch {
500
- break s_255;
567
+ break s__1217_183;
501
568
  }
502
- } else if (genericEq_57(regex_238, End)) {
569
+ } else if (eqGeneric_8(regex_166, End)) {
503
570
  try {
504
- listBuilderAdd_58(this.#out_227, "\u0024");
571
+ listBuilderAdd_9(this.#out_155, "\u0024");
505
572
  } catch {
506
- break s_255;
573
+ break s__1217_183;
507
574
  }
508
- } else if (genericEq_57(regex_238, WordBoundary)) {
575
+ } else if (eqGeneric_8(regex_166, WordBoundary)) {
509
576
  try {
510
- listBuilderAdd_58(this.#out_227, "\\b");
577
+ listBuilderAdd_9(this.#out_155, "\\b");
511
578
  } catch {
512
- break s_255;
579
+ break s__1217_183;
513
580
  }
514
- } else if (genericEq_57(regex_238, Digit)) {
581
+ } else if (eqGeneric_8(regex_166, Digit)) {
515
582
  try {
516
- listBuilderAdd_58(this.#out_227, "\\d");
583
+ listBuilderAdd_9(this.#out_155, "\\d");
517
584
  } catch {
518
- break s_255;
585
+ break s__1217_183;
519
586
  }
520
- } else if (genericEq_57(regex_238, Space)) {
587
+ } else if (eqGeneric_8(regex_166, Space)) {
521
588
  try {
522
- listBuilderAdd_58(this.#out_227, "\\s");
589
+ listBuilderAdd_9(this.#out_155, "\\s");
523
590
  } catch {
524
- break s_255;
591
+ break s__1217_183;
525
592
  }
526
- } else if (genericEq_57(regex_238, Word)) {
593
+ } else if (eqGeneric_8(regex_166, Word)) {
527
594
  try {
528
- listBuilderAdd_58(this.#out_227, "\\w");
595
+ listBuilderAdd_9(this.#out_155, "\\w");
529
596
  } catch {
530
- break s_255;
597
+ break s__1217_183;
531
598
  }
532
599
  }
533
600
  }
@@ -536,670 +603,698 @@ class RegexFormatter_226 {
536
603
  }
537
604
  }
538
605
  }
539
- return return_239;
606
+ return return_167;
540
607
  }
541
- throw noResultException__256;
608
+ throw noResultException__184;
542
609
  }
543
- pushCapture(capture_258) {
544
- let return_259;
545
- let t_260;
546
- let t_261;
547
- return_259 = void 0;
548
- let t_262;
610
+ /**
611
+ * @param {Capture} capture_186
612
+ * @returns {void}
613
+ */
614
+ pushCapture(capture_186) {
615
+ let return_187;
616
+ let t_188;
617
+ let t_189;
618
+ return_187 = void 0;
619
+ let t_190;
549
620
  {
550
- listBuilderAdd_58(this.#out_227, "(");
551
- t_262 = this.#out_227;
552
- t_260 = capture_258.name;
553
- this.pushCaptureName(t_262, t_260);
554
- t_261 = capture_258.item;
555
- this.pushRegex(t_261);
556
- listBuilderAdd_58(this.#out_227, ")");
621
+ listBuilderAdd_9(this.#out_155, "(");
622
+ t_190 = this.#out_155;
623
+ t_188 = capture_186.name;
624
+ this.pushCaptureName(t_190, t_188);
625
+ t_189 = capture_186.item;
626
+ this.pushRegex(t_189);
627
+ listBuilderAdd_9(this.#out_155, ")");
557
628
  }
558
- return return_259;
629
+ return return_187;
559
630
  }
560
- pushCaptureName(out_264, name_265) {
561
- let return_266;
562
- return_266 = void 0;
563
- listBuilderAdd_58(out_264, strCat_10("?\u003c", name_265, "\u003e"));
564
- return return_266;
631
+ /**
632
+ * @param {Array<string>} out_192
633
+ * @param {string} name_193
634
+ * @returns {void}
635
+ */
636
+ pushCaptureName(out_192, name_193) {
637
+ let return_194;
638
+ return_194 = void 0;
639
+ listBuilderAdd_9(out_192, strCat_10("?\u003c", name_193, "\u003e"));
640
+ return return_194;
565
641
  }
566
- pushCode(code_268, insideCodeSet_269) {
567
- let return_270;
568
- return_270 = void 0;
569
- regexFormatterPushCodeTo_59(this, this.#out_227, code_268, insideCodeSet_269);
570
- return return_270;
642
+ /**
643
+ * @param {number} code_196
644
+ * @param {boolean} insideCodeSet_197
645
+ * @returns {void}
646
+ */
647
+ pushCode(code_196, insideCodeSet_197) {
648
+ let return_198;
649
+ return_198 = void 0;
650
+ regexFormatterPushCodeTo_11(this, this.#out_155, code_196, insideCodeSet_197);
651
+ return return_198;
571
652
  }
572
- pushCodePoints(codePoints_272, insideCodeSet_273) {
573
- let return_274;
574
- let t_275;
575
- let t_276;
576
- let t_277;
577
- let t_278;
578
- return_274 = void 0;
579
- let t_279 = codePoints_272.value;
580
- let t_280 = stringCodePoints_8(t_279);
581
- let slice_281 = t_280;
653
+ /**
654
+ * @param {CodePoints} codePoints_200
655
+ * @param {boolean} insideCodeSet_201
656
+ * @returns {void}
657
+ */
658
+ pushCodePoints(codePoints_200, insideCodeSet_201) {
659
+ let return_202;
660
+ let t_203;
661
+ let t_204;
662
+ let t_205;
663
+ return_202 = void 0;
664
+ let t_206 = codePoints_200.value;
665
+ let t_207 = stringCodePoints_12(t_206);
666
+ let slice_208 = t_207;
582
667
  while (true) {
583
- t_275 = slice_281.isEmpty;
584
- t_278 = ! t_275;
585
- if (t_278) {
586
- t_276 = slice_281.read();
587
- this.pushCode(t_276, insideCodeSet_273);
588
- t_277 = slice_281.advance(1);
589
- slice_281 = t_277;
668
+ t_203 = slice_208.isEmpty;
669
+ if (! t_203) {
670
+ t_204 = slice_208.read();
671
+ this.pushCode(t_204, insideCodeSet_201);
672
+ t_205 = slice_208.advance(1);
673
+ slice_208 = t_205;
590
674
  } else {
591
675
  break;
592
676
  }
593
677
  }
594
- return return_274;
678
+ return return_202;
595
679
  }
596
- pushCodeRange(codeRange_283) {
597
- let return_284;
598
- return_284 = void 0;
680
+ /**
681
+ * @param {CodeRange} codeRange_210
682
+ * @returns {void}
683
+ */
684
+ pushCodeRange(codeRange_210) {
685
+ let return_211;
686
+ return_211 = void 0;
599
687
  {
600
- listBuilderAdd_58(this.#out_227, "[");
601
- this.pushCodeRangeUnwrapped(codeRange_283);
602
- listBuilderAdd_58(this.#out_227, "]");
688
+ listBuilderAdd_9(this.#out_155, "[");
689
+ this.pushCodeRangeUnwrapped(codeRange_210);
690
+ listBuilderAdd_9(this.#out_155, "]");
603
691
  }
604
- return return_284;
692
+ return return_211;
605
693
  }
606
- pushCodeRangeUnwrapped(codeRange_286) {
607
- let return_287;
608
- let t_288;
609
- return_287 = void 0;
610
- let t_289 = codeRange_286.min;
611
- this.pushCode(t_289, true);
694
+ /**
695
+ * @param {CodeRange} codeRange_213
696
+ * @returns {void}
697
+ */
698
+ pushCodeRangeUnwrapped(codeRange_213) {
699
+ let return_214;
700
+ let t_215;
701
+ return_214 = void 0;
702
+ let t_216 = codeRange_213.min;
703
+ this.pushCode(t_216, true);
612
704
  {
613
- listBuilderAdd_58(this.#out_227, "-");
614
- t_288 = codeRange_286.max;
615
- this.pushCode(t_288, true);
705
+ listBuilderAdd_9(this.#out_155, "-");
706
+ t_215 = codeRange_213.max;
707
+ this.pushCode(t_215, true);
616
708
  }
617
- return return_287;
709
+ return return_214;
618
710
  }
619
- pushCodeSet(codeSet_291) {
620
- let return_292;
621
- let t_293;
622
- let t_294;
623
- let t_295;
624
- let t_296;
625
- return_292 = void 0;
626
- let t_297;
627
- let t_298;
628
- let t_299;
629
- let t_300;
630
- let t_301;
631
- let t_302 = regexFormatterAdjustCodeSet_60(this, codeSet_291, regexRefs_217);
632
- const adjusted_303 = t_302;
711
+ /**
712
+ * @param {CodeSet} codeSet_218
713
+ * @returns {void}
714
+ */
715
+ pushCodeSet(codeSet_218) {
716
+ let return_219;
717
+ let t_220;
718
+ let t_221;
719
+ let t_222;
720
+ let t_223;
721
+ return_219 = void 0;
722
+ let t_224;
723
+ let t_225;
724
+ let t_226;
725
+ let t_227 = regexFormatterAdjustCodeSet_13(this, codeSet_218, regexRefs_142);
726
+ const adjusted_228 = t_227;
633
727
  try {
634
- requireInstanceOf__254(adjusted_303, CodeSet_116);
635
- t_297 = true;
728
+ requireInstanceOf__182(adjusted_228, CodeSet);
729
+ t_224 = true;
636
730
  } catch {
637
- t_297 = false;
731
+ t_224 = false;
638
732
  }
639
- s_304: {
640
- if (t_297) {
641
- s_305: {
733
+ s__1224_229: {
734
+ if (t_224) {
735
+ s__1225_230: {
642
736
  try {
643
- t_298 = requireInstanceOf__254(adjusted_303, CodeSet_116);
644
- listBuilderAdd_58(this.#out_227, "[");
737
+ t_225 = requireInstanceOf__182(adjusted_228, CodeSet);
738
+ listBuilderAdd_9(this.#out_155, "[");
645
739
  } catch {
646
- break s_305;
740
+ break s__1225_230;
647
741
  }
648
- t_296 = t_298.negated;
649
- if (t_296) {
742
+ t_223 = t_225.negated;
743
+ if (t_223) {
650
744
  try {
651
- listBuilderAdd_58(this.#out_227, "^");
745
+ listBuilderAdd_9(this.#out_155, "^");
652
746
  } catch {
653
- break s_305;
747
+ break s__1225_230;
654
748
  }
655
749
  }
656
- let i_306 = 0;
750
+ let i_231 = 0;
657
751
  while (true) {
658
- t_293 = t_298.items;
659
- t_295 = t_293.length;
660
- try {
661
- t_299 = genericLt_61(i_306, t_295);
662
- } catch {
663
- break;
664
- }
665
- if (t_299) {
666
- t_294 = t_298.items;
752
+ t_220 = t_225.items;
753
+ t_222 = t_220.length;
754
+ if (ltGeneric_14(i_231, t_222)) {
755
+ t_221 = t_225.items;
667
756
  try {
668
- t_301 = listGet_62(t_294, i_306);
757
+ t_226 = listGet_15(t_221, i_231);
669
758
  } catch {
670
- break;
759
+ break s__1225_230;
671
760
  }
672
- this.pushCodeSetItem(t_301);
673
- t_300 = i_306 + 1;
674
- i_306 = t_300;
761
+ this.pushCodeSetItem(t_226);
762
+ i_231 = i_231 + 1;
675
763
  } else {
676
- try {
677
- listBuilderAdd_58(this.#out_227, "]");
678
- } catch {
679
- break s_305;
680
- }
681
- break s_304;
764
+ break;
682
765
  }
683
766
  }
767
+ try {
768
+ listBuilderAdd_9(this.#out_155, "]");
769
+ break s__1224_229;
770
+ } catch {
771
+ }
684
772
  }
685
- throw noResultException__256;
773
+ throw noResultException__184;
686
774
  }
687
- this.pushRegex(adjusted_303);
775
+ this.pushRegex(adjusted_228);
688
776
  }
689
- return return_292;
777
+ return return_219;
690
778
  }
691
- pushCodeSetItem(codePart_308) {
692
- let return_309;
693
- return_309 = void 0;
694
- let t_310;
695
- let t_311;
696
- let t_312;
697
- let t_313;
698
- let t_314;
699
- let t_315;
779
+ /**
780
+ * @param {CodePart} codePart_233
781
+ * @returns {void}
782
+ */
783
+ pushCodeSetItem(codePart_233) {
784
+ let return_234;
785
+ return_234 = void 0;
786
+ let t_235;
787
+ let t_236;
788
+ let t_237;
789
+ let t_238;
790
+ let t_239;
791
+ let t_240;
700
792
  try {
701
- requireInstanceOf__254(codePart_308, CodePoints_98);
702
- t_310 = true;
793
+ requireInstanceOf__182(codePart_233, CodePoints);
794
+ t_235 = true;
703
795
  } catch {
704
- t_310 = false;
796
+ t_235 = false;
705
797
  }
706
- s_316: {
707
- if (t_310) {
798
+ s__1232_241: {
799
+ if (t_235) {
708
800
  try {
709
- t_311 = requireInstanceOf__254(codePart_308, CodePoints_98);
801
+ t_236 = requireInstanceOf__182(codePart_233, CodePoints);
710
802
  } catch {
711
- break s_316;
803
+ break s__1232_241;
712
804
  }
713
- this.pushCodePoints(t_311, true);
805
+ this.pushCodePoints(t_236, true);
714
806
  } else {
715
807
  try {
716
- requireInstanceOf__254(codePart_308, CodeRange_105);
717
- t_312 = true;
808
+ requireInstanceOf__182(codePart_233, CodeRange);
809
+ t_237 = true;
718
810
  } catch {
719
- t_312 = false;
811
+ t_237 = false;
720
812
  }
721
- if (t_312) {
813
+ if (t_237) {
722
814
  try {
723
- t_313 = requireInstanceOf__254(codePart_308, CodeRange_105);
815
+ t_238 = requireInstanceOf__182(codePart_233, CodeRange);
724
816
  } catch {
725
- break s_316;
817
+ break s__1232_241;
726
818
  }
727
- this.pushCodeRangeUnwrapped(t_313);
819
+ this.pushCodeRangeUnwrapped(t_238);
728
820
  } else {
729
821
  try {
730
- requireInstanceOf__254(codePart_308, SpecialSet_72);
731
- t_314 = true;
822
+ requireInstanceOf__182(codePart_233, SpecialSet);
823
+ t_239 = true;
732
824
  } catch {
733
- t_314 = false;
825
+ t_239 = false;
734
826
  }
735
- if (t_314) {
827
+ if (t_239) {
736
828
  try {
737
- t_315 = requireInstanceOf__254(codePart_308, SpecialSet_72);
829
+ t_240 = requireInstanceOf__182(codePart_233, SpecialSet);
738
830
  } catch {
739
- break s_316;
831
+ break s__1232_241;
740
832
  }
741
- this.pushRegex(t_315);
833
+ this.pushRegex(t_240);
742
834
  }
743
835
  }
744
836
  }
745
- return return_309;
837
+ return return_234;
746
838
  }
747
- throw noResultException__256;
839
+ throw noResultException__184;
748
840
  }
749
- pushOr(or_318) {
750
- let return_319;
751
- let t_320;
752
- let t_321;
753
- let t_322;
754
- let t_323;
755
- return_319 = void 0;
756
- let t_324;
757
- let t_325;
758
- let t_326;
759
- let t_327;
760
- let t_328 = or_318.items;
761
- let t_329 = ! t_328.length;
762
- let t_330 = ! t_329;
763
- s_331: if (t_330) {
764
- s_332: {
841
+ /**
842
+ * @param {Or} or_243
843
+ * @returns {void}
844
+ */
845
+ pushOr(or_243) {
846
+ let return_244;
847
+ let t_245;
848
+ let t_246;
849
+ let t_247;
850
+ let t_248;
851
+ return_244 = void 0;
852
+ let t_249;
853
+ let t_250;
854
+ let t_251 = or_243.items;
855
+ let t_252 = ! t_251.length;
856
+ s__1234_253: if (! t_252) {
857
+ s__1235_254: {
765
858
  try {
766
- listBuilderAdd_58(this.#out_227, "(?:");
767
- t_323 = or_318.items;
768
- t_324 = listGet_62(t_323, 0);
859
+ listBuilderAdd_9(this.#out_155, "(?:");
860
+ t_248 = or_243.items;
861
+ t_249 = listGet_15(t_248, 0);
769
862
  } catch {
770
- break s_332;
863
+ break s__1235_254;
771
864
  }
772
- this.pushRegex(t_324);
773
- let i_333 = 1;
865
+ this.pushRegex(t_249);
866
+ let i_255 = 1;
774
867
  while (true) {
775
- t_320 = or_318.items;
776
- t_322 = t_320.length;
777
- try {
778
- t_325 = genericLt_61(i_333, t_322);
779
- } catch {
780
- break;
781
- }
782
- if (t_325) {
868
+ t_245 = or_243.items;
869
+ t_247 = t_245.length;
870
+ if (ltGeneric_14(i_255, t_247)) {
783
871
  try {
784
- listBuilderAdd_58(this.#out_227, "|");
785
- t_321 = or_318.items;
786
- t_327 = listGet_62(t_321, i_333);
872
+ listBuilderAdd_9(this.#out_155, "|");
873
+ t_246 = or_243.items;
874
+ t_250 = listGet_15(t_246, i_255);
787
875
  } catch {
788
876
  break;
789
877
  }
790
- this.pushRegex(t_327);
791
- t_326 = i_333 + 1;
792
- i_333 = t_326;
878
+ this.pushRegex(t_250);
879
+ i_255 = i_255 + 1;
793
880
  } else {
794
881
  try {
795
- listBuilderAdd_58(this.#out_227, ")");
882
+ listBuilderAdd_9(this.#out_155, ")");
796
883
  } catch {
797
- break s_332;
884
+ break s__1235_254;
798
885
  }
799
- break s_331;
886
+ break s__1234_253;
800
887
  }
801
888
  }
802
889
  }
803
- throw noResultException__256;
890
+ throw noResultException__184;
804
891
  }
805
- return return_319;
892
+ return return_244;
806
893
  }
807
- pushRepeat(repeat_335) {
808
- let return_336;
809
- let t_337;
810
- let t_338;
811
- let t_339;
812
- let t_340;
813
- let t_341;
814
- return_336 = void 0;
815
- let t_342;
816
- let t_343;
817
- let t_344;
818
- let t_345;
819
- let t_346;
820
- let t_347;
821
- let t_348;
822
- s_349: {
823
- let min_350;
894
+ /**
895
+ * @param {Repeat} repeat_257
896
+ * @returns {void}
897
+ */
898
+ pushRepeat(repeat_257) {
899
+ let return_258;
900
+ let t_259;
901
+ let t_260;
902
+ let t_261;
903
+ let t_262;
904
+ let t_263;
905
+ return_258 = void 0;
906
+ let t_264;
907
+ let t_265;
908
+ let t_266;
909
+ let t_267;
910
+ let t_268;
911
+ let t_269;
912
+ let t_270;
913
+ s__1239_271: {
914
+ let min_272;
824
915
  try {
825
- listBuilderAdd_58(this.#out_227, "(?:");
826
- t_337 = repeat_335.item;
827
- this.pushRegex(t_337);
828
- listBuilderAdd_58(this.#out_227, ")");
829
- t_338 = repeat_335.min;
830
- min_350 = t_338;
831
- t_342 = repeat_335.max;
916
+ listBuilderAdd_9(this.#out_155, "(?:");
917
+ t_259 = repeat_257.item;
918
+ this.pushRegex(t_259);
919
+ listBuilderAdd_9(this.#out_155, ")");
920
+ t_260 = repeat_257.min;
921
+ min_272 = t_260;
922
+ t_264 = repeat_257.max;
832
923
  } catch {
833
- break s_349;
924
+ break s__1239_271;
834
925
  }
835
- const max_351 = t_342;
836
- if (genericEq_57(min_350, 0)) {
837
- t_343 = genericEq_57(max_351, 1);
926
+ const max_273 = t_264;
927
+ if (eqGeneric_16(min_272, 0)) {
928
+ t_265 = eqGeneric_16(max_273, 1);
838
929
  } else {
839
- t_343 = false;
930
+ t_265 = false;
840
931
  }
841
- if (t_343) {
932
+ if (t_265) {
842
933
  try {
843
- listBuilderAdd_58(this.#out_227, "?");
934
+ listBuilderAdd_9(this.#out_155, "?");
844
935
  } catch {
845
- break s_349;
936
+ break s__1239_271;
846
937
  }
847
938
  } else {
848
- if (genericEq_57(min_350, 0)) {
849
- t_344 = genericEq_57(max_351, null);
939
+ if (eqGeneric_16(min_272, 0)) {
940
+ t_266 = eqGeneric_16(max_273, null);
850
941
  } else {
851
- t_344 = false;
942
+ t_266 = false;
852
943
  }
853
- if (t_344) {
944
+ if (t_266) {
854
945
  try {
855
- listBuilderAdd_58(this.#out_227, "*");
946
+ listBuilderAdd_9(this.#out_155, "*");
856
947
  } catch {
857
- break s_349;
948
+ break s__1239_271;
858
949
  }
859
950
  } else {
860
- if (genericEq_57(min_350, 1)) {
861
- t_345 = genericEq_57(max_351, null);
951
+ if (eqGeneric_16(min_272, 1)) {
952
+ t_267 = eqGeneric_16(max_273, null);
862
953
  } else {
863
- t_345 = false;
954
+ t_267 = false;
864
955
  }
865
- if (t_345) {
956
+ if (t_267) {
866
957
  try {
867
- listBuilderAdd_58(this.#out_227, "+");
958
+ listBuilderAdd_9(this.#out_155, "+");
868
959
  } catch {
869
- break s_349;
960
+ break s__1239_271;
870
961
  }
871
962
  } else {
872
- t_346 = this.#out_227;
873
- t_339 = intToString_9(min_350);
963
+ t_268 = this.#out_155;
964
+ t_261 = intToString_17(min_272);
874
965
  try {
875
- listBuilderAdd_58(t_346, strCat_10("{", t_339));
966
+ listBuilderAdd_9(t_268, strCat_10("{", t_261));
876
967
  } catch {
877
- break s_349;
968
+ break s__1239_271;
878
969
  }
879
- if (genericNe_63(min_350, max_351)) {
970
+ if (neGeneric_18(min_272, max_273)) {
880
971
  try {
881
- listBuilderAdd_58(this.#out_227, ",");
972
+ listBuilderAdd_9(this.#out_155, ",");
882
973
  } catch {
883
- break s_349;
974
+ break s__1239_271;
884
975
  }
885
- if (genericNe_63(max_351, null)) {
886
- t_348 = this.#out_227;
976
+ if (neGeneric_18(max_273, null)) {
977
+ t_270 = this.#out_155;
887
978
  try {
888
- t_347 = requireIsSafeInteger__352(max_351);
889
- t_340 = intToString_9(t_347);
890
- listBuilderAdd_58(t_348, t_340);
979
+ t_269 = requireIsSafeInteger__274(max_273);
980
+ t_262 = intToString_17(t_269);
981
+ listBuilderAdd_9(t_270, t_262);
891
982
  } catch {
892
- break s_349;
983
+ break s__1239_271;
893
984
  }
894
985
  }
895
986
  }
896
987
  try {
897
- listBuilderAdd_58(this.#out_227, "}");
988
+ listBuilderAdd_9(this.#out_155, "}");
898
989
  } catch {
899
- break s_349;
990
+ break s__1239_271;
900
991
  }
901
992
  }
902
993
  }
903
994
  }
904
- t_341 = repeat_335.reluctant;
905
- if (t_341) {
995
+ t_263 = repeat_257.reluctant;
996
+ if (t_263) {
906
997
  try {
907
- listBuilderAdd_58(this.#out_227, "?");
998
+ listBuilderAdd_9(this.#out_155, "?");
908
999
  } catch {
909
- break s_349;
1000
+ break s__1239_271;
910
1001
  }
911
1002
  }
912
- return return_336;
1003
+ return return_258;
913
1004
  }
914
- throw noResultException__256;
1005
+ throw noResultException__184;
915
1006
  }
916
- pushSequence(sequence_354) {
917
- let return_355;
918
- let t_356;
919
- let t_357;
920
- let t_358;
921
- return_355 = void 0;
922
- let t_359;
923
- let t_360;
924
- let t_361;
925
- let i_362 = 0;
926
- s_363: {
1007
+ /**
1008
+ * @param {Sequence} sequence_276
1009
+ * @returns {void}
1010
+ */
1011
+ pushSequence(sequence_276) {
1012
+ let return_277;
1013
+ let t_278;
1014
+ let t_279;
1015
+ let t_280;
1016
+ return_277 = void 0;
1017
+ let t_281;
1018
+ let i_282 = 0;
1019
+ s__1244_283: {
927
1020
  while (true) {
928
- t_356 = sequence_354.items;
929
- t_358 = t_356.length;
930
- try {
931
- t_359 = genericLt_61(i_362, t_358);
932
- } catch {
933
- break;
934
- }
935
- if (t_359) {
936
- t_357 = sequence_354.items;
1021
+ t_278 = sequence_276.items;
1022
+ t_280 = t_278.length;
1023
+ if (ltGeneric_14(i_282, t_280)) {
1024
+ t_279 = sequence_276.items;
937
1025
  try {
938
- t_361 = listGet_62(t_357, i_362);
1026
+ t_281 = listGet_15(t_279, i_282);
939
1027
  } catch {
940
1028
  break;
941
1029
  }
942
- this.pushRegex(t_361);
943
- t_360 = i_362 + 1;
944
- i_362 = t_360;
1030
+ this.pushRegex(t_281);
1031
+ i_282 = i_282 + 1;
945
1032
  } else {
946
- break s_363;
1033
+ break s__1244_283;
947
1034
  }
948
1035
  }
949
- throw noResultException__256;
1036
+ throw noResultException__184;
950
1037
  }
951
- return return_355;
1038
+ return return_277;
952
1039
  }
953
- maxCode(codePart_365) {
954
- let return_366;
955
- let t_367;
956
- let t_368;
957
- let t_369;
958
- let t_370;
959
- let t_371;
960
- let t_372;
961
- let t_373;
962
- let t_374;
963
- let t_375;
964
- let t_376;
965
- let t_377;
966
- let t_378;
967
- let t_379;
968
- let t_380;
969
- let t_381;
970
- let t_382;
971
- let t_383;
972
- let t_384;
973
- let t_385;
974
- let t_386;
975
- let t_387;
976
- let t_388;
1040
+ /**
1041
+ * @param {CodePart} codePart_285
1042
+ * @returns {"Unsupported type: Int | Null"}
1043
+ */
1044
+ maxCode(codePart_285) {
1045
+ let return_286;
1046
+ let t_287;
1047
+ let t_288;
1048
+ let t_289;
1049
+ let t_290;
1050
+ let t_291;
1051
+ let t_292;
1052
+ let t_293;
1053
+ let t_294;
1054
+ let t_295;
1055
+ let t_296;
1056
+ let t_297;
1057
+ let t_298;
1058
+ let t_299;
1059
+ let t_300;
1060
+ let t_301;
1061
+ let t_302;
1062
+ let t_303;
1063
+ let t_304;
1064
+ let t_305;
1065
+ let t_306;
977
1066
  try {
978
- requireInstanceOf__254(codePart_365, CodePoints_98);
979
- t_381 = true;
1067
+ requireInstanceOf__182(codePart_285, CodePoints);
1068
+ t_300 = true;
980
1069
  } catch {
981
- t_381 = false;
1070
+ t_300 = false;
982
1071
  }
983
- s_389: {
984
- if (t_381) {
1072
+ s__1246_307: {
1073
+ if (t_300) {
985
1074
  try {
986
- t_382 = requireInstanceOf__254(codePart_365, CodePoints_98);
1075
+ t_301 = requireInstanceOf__182(codePart_285, CodePoints);
987
1076
  } catch {
988
- break s_389;
1077
+ break s__1246_307;
989
1078
  }
990
- t_370 = t_382.value;
991
- const value_390 = t_370;
992
- t_371 = ! value_390;
993
- if (t_371) {
994
- t_385 = null;
1079
+ t_290 = t_301.value;
1080
+ const value_308 = t_290;
1081
+ t_291 = ! value_308;
1082
+ if (t_291) {
1083
+ t_303 = null;
995
1084
  } else {
996
- let max_391 = 0;
997
- t_372 = stringCodePoints_8(value_390);
998
- let slice_392 = t_372;
1085
+ let max_309 = 0;
1086
+ t_292 = stringCodePoints_12(value_308);
1087
+ let slice_310 = t_292;
999
1088
  while (true) {
1000
- t_373 = slice_392.isEmpty;
1001
- t_376 = ! t_373;
1002
- if (t_376) {
1003
- t_374 = slice_392.read();
1004
- const next_393 = t_374;
1005
- try {
1006
- t_383 = genericGt_64(next_393, max_391);
1007
- } catch {
1008
- break s_389;
1009
- }
1010
- if (t_383) {
1011
- max_391 = next_393;
1089
+ t_293 = slice_310.isEmpty;
1090
+ if (! t_293) {
1091
+ t_294 = slice_310.read();
1092
+ const next_311 = t_294;
1093
+ if (gtGeneric_19(next_311, max_309)) {
1094
+ max_309 = next_311;
1012
1095
  }
1013
- t_375 = slice_392.advance(1);
1014
- slice_392 = t_375;
1096
+ t_295 = slice_310.advance(1);
1097
+ slice_310 = t_295;
1015
1098
  } else {
1016
1099
  break;
1017
1100
  }
1018
1101
  }
1019
- t_384 = max_391;
1020
- t_385 = t_384;
1102
+ t_302 = max_309;
1103
+ t_303 = t_302;
1021
1104
  }
1022
- t_388 = t_385;
1105
+ t_306 = t_303;
1023
1106
  } else {
1024
1107
  try {
1025
- requireInstanceOf__254(codePart_365, CodeRange_105);
1026
- t_386 = true;
1108
+ requireInstanceOf__182(codePart_285, CodeRange);
1109
+ t_304 = true;
1027
1110
  } catch {
1028
- t_386 = false;
1111
+ t_304 = false;
1029
1112
  }
1030
- if (t_386) {
1113
+ if (t_304) {
1031
1114
  try {
1032
- t_387 = requireInstanceOf__254(codePart_365, CodeRange_105);
1115
+ t_305 = requireInstanceOf__182(codePart_285, CodeRange);
1033
1116
  } catch {
1034
- break s_389;
1117
+ break s__1246_307;
1035
1118
  }
1036
- t_377 = t_387.max;
1037
- t_388 = t_377;
1038
- } else if (genericEq_57(codePart_365, Digit)) {
1039
- t_367 = stringCodePoints_8("9");
1040
- t_378 = t_367.read();
1041
- t_388 = t_378;
1042
- } else if (genericEq_57(codePart_365, Space)) {
1043
- t_368 = stringCodePoints_8(" ");
1044
- t_379 = t_368.read();
1045
- t_388 = t_379;
1046
- } else if (genericEq_57(codePart_365, Word)) {
1047
- t_369 = stringCodePoints_8("z");
1048
- t_380 = t_369.read();
1049
- t_388 = t_380;
1119
+ t_296 = t_305.max;
1120
+ t_306 = t_296;
1121
+ } else if (eqGeneric_8(codePart_285, Digit)) {
1122
+ t_287 = stringCodePoints_12("9");
1123
+ t_297 = t_287.read();
1124
+ t_306 = t_297;
1125
+ } else if (eqGeneric_8(codePart_285, Space)) {
1126
+ t_288 = stringCodePoints_12(" ");
1127
+ t_298 = t_288.read();
1128
+ t_306 = t_298;
1129
+ } else if (eqGeneric_8(codePart_285, Word)) {
1130
+ t_289 = stringCodePoints_12("z");
1131
+ t_299 = t_289.read();
1132
+ t_306 = t_299;
1050
1133
  } else {
1051
- t_388 = null;
1134
+ t_306 = null;
1052
1135
  }
1053
1136
  }
1054
1137
  try {
1055
- return_366 = t_388;
1056
- return return_366;
1138
+ return_286 = t_306;
1139
+ return return_286;
1057
1140
  } catch {
1058
1141
  }
1059
1142
  }
1060
- throw noResultException__256;
1143
+ throw noResultException__184;
1061
1144
  }
1062
- constructor(out_394) {
1063
- let return_395;
1064
- let t_396;
1065
- return_395 = void 0;
1066
- if (!(out_394 !== void 0)) {
1067
- t_396 = [];
1068
- out_394 = t_396;
1145
+ /** @param {Array<string>} out_312 */
1146
+ constructor(out_312) {
1147
+ let return_313;
1148
+ let t_314;
1149
+ return_313 = void 0;
1150
+ if (!(out_312 !== void 0)) {
1151
+ t_314 = [];
1152
+ out_312 = t_314;
1069
1153
  }
1070
- this.#out_227 = out_394;
1154
+ this.#out_155 = out_312;
1071
1155
  return;
1072
1156
  }
1073
1157
  }
1074
- let typePlaceholder_397;
1075
- let typePlaceholder_398;
1076
- function Begin_399(...args_400) {
1077
- return new Begin_401(...args_400);
1078
- }
1079
- class Begin_401 {
1158
+ class Begin_315 {
1159
+ /** */
1080
1160
  constructor() {
1081
- let return_402;
1082
- return_402 = void 0;
1161
+ let return_316;
1162
+ return_316 = void 0;
1083
1163
  return;
1084
1164
  }
1085
1165
  }
1086
- Special_70.implementedBy(Begin_401);
1087
- let t_403 = Begin_399();
1088
- export const Begin = t_403;
1166
+ Special.implementedBy(Begin_315);
1167
+ /** @type {Begin_315} */
1168
+ let t_317 = new Begin_315();
1169
+ /** @type {Begin_315} */
1170
+ export const Begin = t_317;
1089
1171
  ;
1090
- function Dot_404(...args_405) {
1091
- return new Dot_406(...args_405);
1092
- }
1093
- class Dot_406 {
1172
+ class Dot_318 {
1173
+ /** */
1094
1174
  constructor() {
1095
- let return_407;
1096
- return_407 = void 0;
1175
+ let return_319;
1176
+ return_319 = void 0;
1097
1177
  return;
1098
1178
  }
1099
1179
  }
1100
- Special_70.implementedBy(Dot_406);
1101
- let t_408 = Dot_404();
1102
- export const Dot = t_408;
1180
+ Special.implementedBy(Dot_318);
1181
+ /** @type {Dot_318} */
1182
+ let t_320 = new Dot_318();
1183
+ /** @type {Dot_318} */
1184
+ export const Dot = t_320;
1103
1185
  ;
1104
- function End_409(...args_410) {
1105
- return new End_411(...args_410);
1106
- }
1107
- class End_411 {
1186
+ class End_321 {
1187
+ /** */
1108
1188
  constructor() {
1109
- let return_412;
1110
- return_412 = void 0;
1189
+ let return_322;
1190
+ return_322 = void 0;
1111
1191
  return;
1112
1192
  }
1113
1193
  }
1114
- Special_70.implementedBy(End_411);
1115
- let t_413 = End_409();
1116
- export const End = t_413;
1194
+ Special.implementedBy(End_321);
1195
+ /** @type {End_321} */
1196
+ let t_323 = new End_321();
1197
+ /** @type {End_321} */
1198
+ export const End = t_323;
1117
1199
  ;
1118
- function WordBoundary_414(...args_415) {
1119
- return new WordBoundary_416(...args_415);
1120
- }
1121
- class WordBoundary_416 {
1200
+ class WordBoundary_324 {
1201
+ /** */
1122
1202
  constructor() {
1123
- let return_417;
1124
- return_417 = void 0;
1203
+ let return_325;
1204
+ return_325 = void 0;
1125
1205
  return;
1126
1206
  }
1127
1207
  }
1128
- Special_70.implementedBy(WordBoundary_416);
1129
- let t_418 = WordBoundary_414();
1130
- export const WordBoundary = t_418;
1208
+ Special.implementedBy(WordBoundary_324);
1209
+ /** @type {WordBoundary_324} */
1210
+ let t_326 = new WordBoundary_324();
1211
+ /** @type {WordBoundary_324} */
1212
+ export const WordBoundary = t_326;
1131
1213
  ;
1132
- let typePlaceholder_419;
1133
- function Digit_420(...args_421) {
1134
- return new Digit_422(...args_421);
1135
- }
1136
- class Digit_422 {
1214
+ class Digit_327 {
1215
+ /** */
1137
1216
  constructor() {
1138
- let return_423;
1139
- return_423 = void 0;
1217
+ let return_328;
1218
+ return_328 = void 0;
1140
1219
  return;
1141
1220
  }
1142
1221
  }
1143
- SpecialSet_72.implementedBy(Digit_422);
1144
- let t_424 = Digit_420();
1145
- export const Digit = t_424;
1222
+ SpecialSet.implementedBy(Digit_327);
1223
+ /** @type {Digit_327} */
1224
+ let t_329 = new Digit_327();
1225
+ /** @type {Digit_327} */
1226
+ export const Digit = t_329;
1146
1227
  ;
1147
- function Space_425(...args_426) {
1148
- return new Space_427(...args_426);
1149
- }
1150
- class Space_427 {
1228
+ class Space_330 {
1229
+ /** */
1151
1230
  constructor() {
1152
- let return_428;
1153
- return_428 = void 0;
1231
+ let return_331;
1232
+ return_331 = void 0;
1154
1233
  return;
1155
1234
  }
1156
1235
  }
1157
- SpecialSet_72.implementedBy(Space_427);
1158
- let t_429 = Space_425();
1159
- export const Space = t_429;
1236
+ SpecialSet.implementedBy(Space_330);
1237
+ /** @type {Space_330} */
1238
+ let t_332 = new Space_330();
1239
+ /** @type {Space_330} */
1240
+ export const Space = t_332;
1160
1241
  ;
1161
- function Word_430(...args_431) {
1162
- return new Word_432(...args_431);
1163
- }
1164
- class Word_432 {
1242
+ class Word_333 {
1243
+ /** */
1165
1244
  constructor() {
1166
- let return_433;
1167
- return_433 = void 0;
1245
+ let return_334;
1246
+ return_334 = void 0;
1168
1247
  return;
1169
1248
  }
1170
1249
  }
1171
- SpecialSet_72.implementedBy(Word_432);
1172
- let t_434 = Word_430();
1173
- export const Word = t_434;
1250
+ SpecialSet.implementedBy(Word_333);
1251
+ /** @type {Word_333} */
1252
+ let t_335 = new Word_333();
1253
+ /** @type {Word_333} */
1254
+ export const Word = t_335;
1174
1255
  ;
1175
- export function entire(item_435) {
1176
- let return_436;
1177
- let t_437 = Sequence(listify_52(Begin, item_435, End));
1178
- return_436 = t_437;
1179
- return return_436;
1256
+ /**
1257
+ * @param {Regex} item_336
1258
+ * @returns {Regex}
1259
+ */
1260
+ export function entire(item_336) {
1261
+ let return_337;
1262
+ let t_338 = new Sequence(listify_2(Begin, item_336, End));
1263
+ return_337 = t_338;
1264
+ return return_337;
1180
1265
  };
1181
- export function oneOrMore(item_438, reluctant_439) {
1182
- let return_440;
1183
- if (!(reluctant_439 !== void 0)) {
1184
- reluctant_439 = false;
1266
+ /**
1267
+ * @param {Regex} item_339
1268
+ * @param {boolean} reluctant_340
1269
+ * @returns {Repeat}
1270
+ */
1271
+ export function oneOrMore(item_339, reluctant_340) {
1272
+ let return_341;
1273
+ if (!(reluctant_340 !== void 0)) {
1274
+ reluctant_340 = false;
1185
1275
  }
1186
- let t_441 = Repeat(item_438, 1, null, reluctant_439);
1187
- return_440 = t_441;
1188
- return return_440;
1276
+ let t_342 = new Repeat(item_339, 1, null, reluctant_340);
1277
+ return_341 = t_342;
1278
+ return return_341;
1189
1279
  };
1190
- export function optional(item_442, reluctant_443) {
1191
- let return_444;
1192
- if (!(reluctant_443 !== void 0)) {
1193
- reluctant_443 = false;
1280
+ /**
1281
+ * @param {Regex} item_343
1282
+ * @param {boolean} reluctant_344
1283
+ * @returns {Repeat}
1284
+ */
1285
+ export function optional(item_343, reluctant_344) {
1286
+ let return_345;
1287
+ if (!(reluctant_344 !== void 0)) {
1288
+ reluctant_344 = false;
1194
1289
  }
1195
- let t_445 = Repeat(item_442, 0, 1, reluctant_443);
1196
- return_444 = t_445;
1197
- return return_444;
1198
- };
1199
- let t_446 = RegexRefs_181();
1200
- const regexRefs_217 = t_446;
1201
- const return_447 = RegexFormatter_221;
1202
- export default return_447;
1203
- export {
1204
- InterfaceType_51
1290
+ let t_346 = new Repeat(item_343, 0, 1, reluctant_344);
1291
+ return_345 = t_346;
1292
+ return return_345;
1205
1293
  };
1294
+ /** @type {RegexRefs_111} */
1295
+ let t_347 = new RegexRefs_111();
1296
+ /** @type {RegexRefs_111} */
1297
+ const regexRefs_142 = t_347;
1298
+ /** @type {Type_349} */
1299
+ const return_348 = "RegexFormatter__29: Type";
1300
+ export default return_348;