@temperlang/std 0.0.3

package/regex.js

@@ -0,0 +1,1205 @@
+import {
+  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
+} from "@temperlang/core";
+export function Regex(x_65) {
+  return x_65 instanceof Regex_66;
+};
+export function CodePart(x_67) {
+  return x_67 instanceof CodePart_68;
+};
+export function Special(x_69) {
+  return x_69 instanceof Special_70;
+};
+export function SpecialSet(x_71) {
+  return x_71 instanceof SpecialSet_72;
+};
+function methodCompiled73() {
+  let return_74;
+  let t_75 = CompiledRegex(this);
+  return_74 = t_75;
+  return return_74;
+}
+function methodFoundIn76(text_77) {
+  let return_78;
+  let t_79 = this.compiled();
+  let t_80 = t_79.foundIn(text_77);
+  return_78 = t_80;
+  return return_78;
+}
+function methodFind81(text_82) {
+  let return_83;
+  let t_84;
+  let t_85 = this.compiled();
+  {
+    t_84 = t_85.find(text_82);
+    return_83 = t_84;
+  }
+  return return_83;
+}
+const Regex_66 = new InterfaceType_51("Regex", [["m", "compiled", methodCompiled73], ["m", "foundIn", methodFoundIn76], ["m", "find", methodFind81]], [], 1);
+export function Capture(...args_86) {
+  return new Capture_87(...args_86);
+};
+class Capture_87 {
+  #name_88;
+  #item_89;
+  constructor(name_90, item_91) {
+    let return_92;
+    return_92 = void 0;
+    this.#name_88 = name_90;
+    this.#item_89 = item_91;
+    return;
+  }
+  get name() {
+    let return_94;
+    return_94 = this.#name_88;
+    return return_94;
+  }
+  get item() {
+    let return_96;
+    return_96 = this.#item_89;
+    return return_96;
+  }
+}
+Regex_66.implementedBy(Capture_87);
+const CodePart_68 = new InterfaceType_51("CodePart", [], [Regex_66], 2);
+export function CodePoints(...args_97) {
+  return new CodePoints_98(...args_97);
+};
+class CodePoints_98 {
+  #value_99;
+  constructor(value_100) {
+    let return_101;
+    return_101 = void 0;
+    this.#value_99 = value_100;
+    return;
+  }
+  get value() {
+    let return_103;
+    return_103 = this.#value_99;
+    return return_103;
+  }
+}
+CodePart_68.implementedBy(CodePoints_98);
+const Special_70 = new InterfaceType_51("Special", [], [Regex_66], 2);
+const SpecialSet_72 = new InterfaceType_51("SpecialSet", [], [CodePart_68, Special_70], 3);
+export function CodeRange(...args_104) {
+  return new CodeRange_105(...args_104);
+};
+class CodeRange_105 {
+  #min_106;
+  #max_107;
+  constructor(min_108, max_109) {
+    let return_110;
+    return_110 = void 0;
+    this.#min_106 = min_108;
+    this.#max_107 = max_109;
+    return;
+  }
+  get min() {
+    let return_112;
+    return_112 = this.#min_106;
+    return return_112;
+  }
+  get max() {
+    let return_114;
+    return_114 = this.#max_107;
+    return return_114;
+  }
+}
+CodePart_68.implementedBy(CodeRange_105);
+export function CodeSet(...args_115) {
+  return new CodeSet_116(...args_115);
+};
+class CodeSet_116 {
+  #items_117;
+  #negated_118;
+  constructor(items_119, negated_120) {
+    let return_121;
+    return_121 = void 0;
+    if (!(negated_120 !== void 0)) {
+      negated_120 = false;
+    }
+    this.#items_117 = items_119;
+    this.#negated_118 = negated_120;
+    return;
+  }
+  get items() {
+    let return_123;
+    return_123 = this.#items_117;
+    return return_123;
+  }
+  get negated() {
+    let return_125;
+    return_125 = this.#negated_118;
+    return return_125;
+  }
+}
+Regex_66.implementedBy(CodeSet_116);
+export function Or(...args_126) {
+  return new Or_127(...args_126);
+};
+class Or_127 {
+  #items_128;
+  constructor(items_129) {
+    let return_130;
+    return_130 = void 0;
+    this.#items_128 = items_129;
+    return;
+  }
+  get items() {
+    let return_132;
+    return_132 = this.#items_128;
+    return return_132;
+  }
+}
+Regex_66.implementedBy(Or_127);
+export function Repeat(...args_133) {
+  return new Repeat_134(...args_133);
+};
+class Repeat_134 {
+  #item_135;
+  #min_136;
+  #max_137;
+  #reluctant_138;
+  constructor(item_139, min_140, max_141, reluctant_142) {
+    let return_143;
+    return_143 = void 0;
+    if (!(reluctant_142 !== void 0)) {
+      reluctant_142 = false;
+    }
+    this.#item_135 = item_139;
+    this.#min_136 = min_140;
+    this.#max_137 = max_141;
+    this.#reluctant_138 = reluctant_142;
+    return;
+  }
+  get item() {
+    let return_145;
+    return_145 = this.#item_135;
+    return return_145;
+  }
+  get min() {
+    let return_147;
+    return_147 = this.#min_136;
+    return return_147;
+  }
+  get max() {
+    let return_149;
+    return_149 = this.#max_137;
+    return return_149;
+  }
+  get reluctant() {
+    let return_151;
+    return_151 = this.#reluctant_138;
+    return return_151;
+  }
+}
+Regex_66.implementedBy(Repeat_134);
+export function Sequence(...args_152) {
+  return new Sequence_153(...args_152);
+};
+class Sequence_153 {
+  #items_154;
+  constructor(items_155) {
+    let return_156;
+    return_156 = void 0;
+    this.#items_154 = items_155;
+    return;
+  }
+  get items() {
+    let return_158;
+    return_158 = this.#items_154;
+    return return_158;
+  }
+}
+Regex_66.implementedBy(Sequence_153);
+export function Match(...args_159) {
+  return new Match_160(...args_159);
+};
+class Match_160 {
+  #groups_161;
+  constructor(groups_162) {
+    let return_163;
+    return_163 = void 0;
+    this.#groups_161 = groups_162;
+    return;
+  }
+  get groups() {
+    let return_165;
+    return_165 = this.#groups_161;
+    return return_165;
+  }
+}
+export function Group(...args_166) {
+  return new Group_167(...args_166);
+};
+class Group_167 {
+  #name_168;
+  #value_169;
+  #codePointsBegin_170;
+  constructor(name_171, value_172, codePointsBegin_173) {
+    let return_174;
+    return_174 = void 0;
+    this.#name_168 = name_171;
+    this.#value_169 = value_172;
+    this.#codePointsBegin_170 = codePointsBegin_173;
+    return;
+  }
+  get name() {
+    let return_176;
+    return_176 = this.#name_168;
+    return return_176;
+  }
+  get value() {
+    let return_178;
+    return_178 = this.#value_169;
+    return return_178;
+  }
+  get codePointsBegin() {
+    let return_180;
+    return_180 = this.#codePointsBegin_170;
+    return return_180;
+  }
+}
+function RegexRefs_181(...args_182) {
+  return new RegexRefs_183(...args_182);
+}
+class RegexRefs_183 {
+  #codePoints_184;
+  #match_185;
+  #orObject_186;
+  constructor(codePoints_187, match_188, orObject_189) {
+    let return_190;
+    let t_191;
+    let t_192;
+    let t_193;
+    let t_194;
+    return_190 = void 0;
+    if (!(codePoints_187 !== void 0)) {
+      t_191 = CodePoints("");
+      codePoints_187 = t_191;
+    }
+    if (!(match_188 !== void 0)) {
+      t_192 = Group("", "", 0);
+      t_193 = Match(listify_52(t_192));
+      match_188 = t_193;
+    }
+    if (!(orObject_189 !== void 0)) {
+      t_194 = Or(listify_52());
+      orObject_189 = t_194;
+    }
+    this.#codePoints_184 = codePoints_187;
+    this.#match_185 = match_188;
+    this.#orObject_186 = orObject_189;
+    return;
+  }
+  get codePoints() {
+    let return_196;
+    return_196 = this.#codePoints_184;
+    return return_196;
+  }
+  get match() {
+    let return_198;
+    return_198 = this.#match_185;
+    return return_198;
+  }
+  get orObject() {
+    let return_200;
+    return_200 = this.#orObject_186;
+    return return_200;
+  }
+}
+export function CompiledRegex(...args_201) {
+  return new CompiledRegex_202(...args_201);
+};
+class CompiledRegex_202 {
+  #data_203;
+  constructor(data_204) {
+    let return_205;
+    return_205 = void 0;
+    this.#data_203 = data_204;
+    let t_206 = this.format();
+    let t_207 = compiledRegexCompileFormatted_53(this, t_206);
+    this.#compiled_208 = t_207;
+    return;
+  }
+  foundIn(text_210) {
+    let return_211;
+    let t_212 = compiledRegexCompiledFoundIn_54(this, this.#compiled_208, text_210);
+    return_211 = t_212;
+    return return_211;
+  }
+  find(text_214) {
+    let return_215;
+    let t_216;
+    {
+      t_216 = compiledRegexCompiledFind_55(this, this.#compiled_208, text_214, regexRefs_217);
+      return_215 = t_216;
+    }
+    return return_215;
+  }
+  #compiled_208;
+  format() {
+    let return_219;
+    let t_220 = RegexFormatter_221();
+    let t_222 = t_220.format(this.#data_203);
+    return_219 = t_222;
+    return return_219;
+  }
+  get data() {
+    let return_224;
+    return_224 = this.#data_203;
+    return return_224;
+  }
+}
+function RegexFormatter_221(...args_225) {
+  return new RegexFormatter_226(...args_225);
+}
+class RegexFormatter_226 {
+  #out_227;
+  format(regex_229) {
+    let return_230;
+    this.pushRegex(regex_229);
+    let t_231 = this.#out_227;
+    function fn_232(x_233) {
+      let return_234;
+      return_234 = x_233;
+      return return_234;
+    }
+    let t_235 = fn_232;
+    let t_236 = listJoin_56(t_231, "", t_235);
+    return_230 = t_236;
+    return return_230;
+  }
+  pushRegex(regex_238) {
+    let return_239;
+    return_239 = void 0;
+    let t_240;
+    let t_241;
+    let t_242;
+    let t_243;
+    let t_244;
+    let t_245;
+    let t_246;
+    let t_247;
+    let t_248;
+    let t_249;
+    let t_250;
+    let t_251;
+    let t_252;
+    let t_253;
+    try {
+      requireInstanceOf__254(regex_238, Capture_87);
+      t_240 = true;
+    } catch {
+      t_240 = false;
+    }
+    s_255: {
+      if (t_240) {
+        try {
+          t_241 = requireInstanceOf__254(regex_238, Capture_87);
+        } catch {
+          break s_255;
+        }
+        this.pushCapture(t_241);
+      } else {
+        try {
+          requireInstanceOf__254(regex_238, CodePoints_98);
+          t_242 = true;
+        } catch {
+          t_242 = false;
+        }
+        if (t_242) {
+          try {
+            t_243 = requireInstanceOf__254(regex_238, CodePoints_98);
+          } catch {
+            break s_255;
+          }
+          this.pushCodePoints(t_243, false);
+        } else {
+          try {
+            requireInstanceOf__254(regex_238, CodeRange_105);
+            t_244 = true;
+          } catch {
+            t_244 = false;
+          }
+          if (t_244) {
+            try {
+              t_245 = requireInstanceOf__254(regex_238, CodeRange_105);
+            } catch {
+              break s_255;
+            }
+            this.pushCodeRange(t_245);
+          } else {
+            try {
+              requireInstanceOf__254(regex_238, CodeSet_116);
+              t_246 = true;
+            } catch {
+              t_246 = false;
+            }
+            if (t_246) {
+              try {
+                t_247 = requireInstanceOf__254(regex_238, CodeSet_116);
+              } catch {
+                break s_255;
+              }
+              this.pushCodeSet(t_247);
+            } else {
+              try {
+                requireInstanceOf__254(regex_238, Or_127);
+                t_248 = true;
+              } catch {
+                t_248 = false;
+              }
+              if (t_248) {
+                try {
+                  t_249 = requireInstanceOf__254(regex_238, Or_127);
+                } catch {
+                  break s_255;
+                }
+                this.pushOr(t_249);
+              } else {
+                try {
+                  requireInstanceOf__254(regex_238, Repeat_134);
+                  t_250 = true;
+                } catch {
+                  t_250 = false;
+                }
+                if (t_250) {
+                  try {
+                    t_251 = requireInstanceOf__254(regex_238, Repeat_134);
+                  } catch {
+                    break s_255;
+                  }
+                  this.pushRepeat(t_251);
+                } else {
+                  try {
+                    requireInstanceOf__254(regex_238, Sequence_153);
+                    t_252 = true;
+                  } catch {
+                    t_252 = false;
+                  }
+                  if (t_252) {
+                    try {
+                      t_253 = requireInstanceOf__254(regex_238, Sequence_153);
+                    } catch {
+                      break s_255;
+                    }
+                    this.pushSequence(t_253);
+                  } else if (genericEq_57(regex_238, Begin)) {
+                    try {
+                      listBuilderAdd_58(this.#out_227, "^");
+                    } catch {
+                      break s_255;
+                    }
+                  } else if (genericEq_57(regex_238, Dot)) {
+                    try {
+                      listBuilderAdd_58(this.#out_227, ".");
+                    } catch {
+                      break s_255;
+                    }
+                  } else if (genericEq_57(regex_238, End)) {
+                    try {
+                      listBuilderAdd_58(this.#out_227, "\u0024");
+                    } catch {
+                      break s_255;
+                    }
+                  } else if (genericEq_57(regex_238, WordBoundary)) {
+                    try {
+                      listBuilderAdd_58(this.#out_227, "\\b");
+                    } catch {
+                      break s_255;
+                    }
+                  } else if (genericEq_57(regex_238, Digit)) {
+                    try {
+                      listBuilderAdd_58(this.#out_227, "\\d");
+                    } catch {
+                      break s_255;
+                    }
+                  } else if (genericEq_57(regex_238, Space)) {
+                    try {
+                      listBuilderAdd_58(this.#out_227, "\\s");
+                    } catch {
+                      break s_255;
+                    }
+                  } else if (genericEq_57(regex_238, Word)) {
+                    try {
+                      listBuilderAdd_58(this.#out_227, "\\w");
+                    } catch {
+                      break s_255;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return return_239;
+    }
+    throw noResultException__256;
+  }
+  pushCapture(capture_258) {
+    let return_259;
+    let t_260;
+    let t_261;
+    return_259 = void 0;
+    let t_262;
+    {
+      listBuilderAdd_58(this.#out_227, "(");
+      t_262 = this.#out_227;
+      t_260 = capture_258.name;
+      this.pushCaptureName(t_262, t_260);
+      t_261 = capture_258.item;
+      this.pushRegex(t_261);
+      listBuilderAdd_58(this.#out_227, ")");
+    }
+    return return_259;
+  }
+  pushCaptureName(out_264, name_265) {
+    let return_266;
+    return_266 = void 0;
+    listBuilderAdd_58(out_264, strCat_10("?\u003c", name_265, "\u003e"));
+    return return_266;
+  }
+  pushCode(code_268, insideCodeSet_269) {
+    let return_270;
+    return_270 = void 0;
+    regexFormatterPushCodeTo_59(this, this.#out_227, code_268, insideCodeSet_269);
+    return return_270;
+  }
+  pushCodePoints(codePoints_272, insideCodeSet_273) {
+    let return_274;
+    let t_275;
+    let t_276;
+    let t_277;
+    let t_278;
+    return_274 = void 0;
+    let t_279 = codePoints_272.value;
+    let t_280 = stringCodePoints_8(t_279);
+    let slice_281 = t_280;
+    while (true) {
+      t_275 = slice_281.isEmpty;
+      t_278 = ! t_275;
+      if (t_278) {
+        t_276 = slice_281.read();
+        this.pushCode(t_276, insideCodeSet_273);
+        t_277 = slice_281.advance(1);
+        slice_281 = t_277;
+      } else {
+        break;
+      }
+    }
+    return return_274;
+  }
+  pushCodeRange(codeRange_283) {
+    let return_284;
+    return_284 = void 0;
+    {
+      listBuilderAdd_58(this.#out_227, "[");
+      this.pushCodeRangeUnwrapped(codeRange_283);
+      listBuilderAdd_58(this.#out_227, "]");
+    }
+    return return_284;
+  }
+  pushCodeRangeUnwrapped(codeRange_286) {
+    let return_287;
+    let t_288;
+    return_287 = void 0;
+    let t_289 = codeRange_286.min;
+    this.pushCode(t_289, true);
+    {
+      listBuilderAdd_58(this.#out_227, "-");
+      t_288 = codeRange_286.max;
+      this.pushCode(t_288, true);
+    }
+    return return_287;
+  }
+  pushCodeSet(codeSet_291) {
+    let return_292;
+    let t_293;
+    let t_294;
+    let t_295;
+    let t_296;
+    return_292 = void 0;
+    let t_297;
+    let t_298;
+    let t_299;
+    let t_300;
+    let t_301;
+    let t_302 = regexFormatterAdjustCodeSet_60(this, codeSet_291, regexRefs_217);
+    const adjusted_303 = t_302;
+    try {
+      requireInstanceOf__254(adjusted_303, CodeSet_116);
+      t_297 = true;
+    } catch {
+      t_297 = false;
+    }
+    s_304: {
+      if (t_297) {
+        s_305: {
+          try {
+            t_298 = requireInstanceOf__254(adjusted_303, CodeSet_116);
+            listBuilderAdd_58(this.#out_227, "[");
+          } catch {
+            break s_305;
+          }
+          t_296 = t_298.negated;
+          if (t_296) {
+            try {
+              listBuilderAdd_58(this.#out_227, "^");
+            } catch {
+              break s_305;
+            }
+          }
+          let i_306 = 0;
+          while (true) {
+            t_293 = t_298.items;
+            t_295 = t_293.length;
+            try {
+              t_299 = genericLt_61(i_306, t_295);
+            } catch {
+              break;
+            }
+            if (t_299) {
+              t_294 = t_298.items;
+              try {
+                t_301 = listGet_62(t_294, i_306);
+              } catch {
+                break;
+              }
+              this.pushCodeSetItem(t_301);
+              t_300 = i_306 + 1;
+              i_306 = t_300;
+            } else {
+              try {
+                listBuilderAdd_58(this.#out_227, "]");
+              } catch {
+                break s_305;
+              }
+              break s_304;
+            }
+          }
+        }
+        throw noResultException__256;
+      }
+      this.pushRegex(adjusted_303);
+    }
+    return return_292;
+  }
+  pushCodeSetItem(codePart_308) {
+    let return_309;
+    return_309 = void 0;
+    let t_310;
+    let t_311;
+    let t_312;
+    let t_313;
+    let t_314;
+    let t_315;
+    try {
+      requireInstanceOf__254(codePart_308, CodePoints_98);
+      t_310 = true;
+    } catch {
+      t_310 = false;
+    }
+    s_316: {
+      if (t_310) {
+        try {
+          t_311 = requireInstanceOf__254(codePart_308, CodePoints_98);
+        } catch {
+          break s_316;
+        }
+        this.pushCodePoints(t_311, true);
+      } else {
+        try {
+          requireInstanceOf__254(codePart_308, CodeRange_105);
+          t_312 = true;
+        } catch {
+          t_312 = false;
+        }
+        if (t_312) {
+          try {
+            t_313 = requireInstanceOf__254(codePart_308, CodeRange_105);
+          } catch {
+            break s_316;
+          }
+          this.pushCodeRangeUnwrapped(t_313);
+        } else {
+          try {
+            requireInstanceOf__254(codePart_308, SpecialSet_72);
+            t_314 = true;
+          } catch {
+            t_314 = false;
+          }
+          if (t_314) {
+            try {
+              t_315 = requireInstanceOf__254(codePart_308, SpecialSet_72);
+            } catch {
+              break s_316;
+            }
+            this.pushRegex(t_315);
+          }
+        }
+      }
+      return return_309;
+    }
+    throw noResultException__256;
+  }
+  pushOr(or_318) {
+    let return_319;
+    let t_320;
+    let t_321;
+    let t_322;
+    let t_323;
+    return_319 = void 0;
+    let t_324;
+    let t_325;
+    let t_326;
+    let t_327;
+    let t_328 = or_318.items;
+    let t_329 = ! t_328.length;
+    let t_330 = ! t_329;
+    s_331: if (t_330) {
+      s_332: {
+        try {
+          listBuilderAdd_58(this.#out_227, "(?:");
+          t_323 = or_318.items;
+          t_324 = listGet_62(t_323, 0);
+        } catch {
+          break s_332;
+        }
+        this.pushRegex(t_324);
+        let i_333 = 1;
+        while (true) {
+          t_320 = or_318.items;
+          t_322 = t_320.length;
+          try {
+            t_325 = genericLt_61(i_333, t_322);
+          } catch {
+            break;
+          }
+          if (t_325) {
+            try {
+              listBuilderAdd_58(this.#out_227, "|");
+              t_321 = or_318.items;
+              t_327 = listGet_62(t_321, i_333);
+            } catch {
+              break;
+            }
+            this.pushRegex(t_327);
+            t_326 = i_333 + 1;
+            i_333 = t_326;
+          } else {
+            try {
+              listBuilderAdd_58(this.#out_227, ")");
+            } catch {
+              break s_332;
+            }
+            break s_331;
+          }
+        }
+      }
+      throw noResultException__256;
+    }
+    return return_319;
+  }
+  pushRepeat(repeat_335) {
+    let return_336;
+    let t_337;
+    let t_338;
+    let t_339;
+    let t_340;
+    let t_341;
+    return_336 = void 0;
+    let t_342;
+    let t_343;
+    let t_344;
+    let t_345;
+    let t_346;
+    let t_347;
+    let t_348;
+    s_349: {
+      let min_350;
+      try {
+        listBuilderAdd_58(this.#out_227, "(?:");
+        t_337 = repeat_335.item;
+        this.pushRegex(t_337);
+        listBuilderAdd_58(this.#out_227, ")");
+        t_338 = repeat_335.min;
+        min_350 = t_338;
+        t_342 = repeat_335.max;
+      } catch {
+        break s_349;
+      }
+      const max_351 = t_342;
+      if (genericEq_57(min_350, 0)) {
+        t_343 = genericEq_57(max_351, 1);
+      } else {
+        t_343 = false;
+      }
+      if (t_343) {
+        try {
+          listBuilderAdd_58(this.#out_227, "?");
+        } catch {
+          break s_349;
+        }
+      } else {
+        if (genericEq_57(min_350, 0)) {
+          t_344 = genericEq_57(max_351, null);
+        } else {
+          t_344 = false;
+        }
+        if (t_344) {
+          try {
+            listBuilderAdd_58(this.#out_227, "*");
+          } catch {
+            break s_349;
+          }
+        } else {
+          if (genericEq_57(min_350, 1)) {
+            t_345 = genericEq_57(max_351, null);
+          } else {
+            t_345 = false;
+          }
+          if (t_345) {
+            try {
+              listBuilderAdd_58(this.#out_227, "+");
+            } catch {
+              break s_349;
+            }
+          } else {
+            t_346 = this.#out_227;
+            t_339 = intToString_9(min_350);
+            try {
+              listBuilderAdd_58(t_346, strCat_10("{", t_339));
+            } catch {
+              break s_349;
+            }
+            if (genericNe_63(min_350, max_351)) {
+              try {
+                listBuilderAdd_58(this.#out_227, ",");
+              } catch {
+                break s_349;
+              }
+              if (genericNe_63(max_351, null)) {
+                t_348 = this.#out_227;
+                try {
+                  t_347 = requireIsSafeInteger__352(max_351);
+                  t_340 = intToString_9(t_347);
+                  listBuilderAdd_58(t_348, t_340);
+                } catch {
+                  break s_349;
+                }
+              }
+            }
+            try {
+              listBuilderAdd_58(this.#out_227, "}");
+            } catch {
+              break s_349;
+            }
+          }
+        }
+      }
+      t_341 = repeat_335.reluctant;
+      if (t_341) {
+        try {
+          listBuilderAdd_58(this.#out_227, "?");
+        } catch {
+          break s_349;
+        }
+      }
+      return return_336;
+    }
+    throw noResultException__256;
+  }
+  pushSequence(sequence_354) {
+    let return_355;
+    let t_356;
+    let t_357;
+    let t_358;
+    return_355 = void 0;
+    let t_359;
+    let t_360;
+    let t_361;
+    let i_362 = 0;
+    s_363: {
+      while (true) {
+        t_356 = sequence_354.items;
+        t_358 = t_356.length;
+        try {
+          t_359 = genericLt_61(i_362, t_358);
+        } catch {
+          break;
+        }
+        if (t_359) {
+          t_357 = sequence_354.items;
+          try {
+            t_361 = listGet_62(t_357, i_362);
+          } catch {
+            break;
+          }
+          this.pushRegex(t_361);
+          t_360 = i_362 + 1;
+          i_362 = t_360;
+        } else {
+          break s_363;
+        }
+      }
+      throw noResultException__256;
+    }
+    return return_355;
+  }
+  maxCode(codePart_365) {
+    let return_366;
+    let t_367;
+    let t_368;
+    let t_369;
+    let t_370;
+    let t_371;
+    let t_372;
+    let t_373;
+    let t_374;
+    let t_375;
+    let t_376;
+    let t_377;
+    let t_378;
+    let t_379;
+    let t_380;
+    let t_381;
+    let t_382;
+    let t_383;
+    let t_384;
+    let t_385;
+    let t_386;
+    let t_387;
+    let t_388;
+    try {
+      requireInstanceOf__254(codePart_365, CodePoints_98);
+      t_381 = true;
+    } catch {
+      t_381 = false;
+    }
+    s_389: {
+      if (t_381) {
+        try {
+          t_382 = requireInstanceOf__254(codePart_365, CodePoints_98);
+        } catch {
+          break s_389;
+        }
+        t_370 = t_382.value;
+        const value_390 = t_370;
+        t_371 = ! value_390;
+        if (t_371) {
+          t_385 = null;
+        } else {
+          let max_391 = 0;
+          t_372 = stringCodePoints_8(value_390);
+          let slice_392 = t_372;
+          while (true) {
+            t_373 = slice_392.isEmpty;
+            t_376 = ! t_373;
+            if (t_376) {
+              t_374 = slice_392.read();
+              const next_393 = t_374;
+              try {
+                t_383 = genericGt_64(next_393, max_391);
+              } catch {
+                break s_389;
+              }
+              if (t_383) {
+                max_391 = next_393;
+              }
+              t_375 = slice_392.advance(1);
+              slice_392 = t_375;
+            } else {
+              break;
+            }
+          }
+          t_384 = max_391;
+          t_385 = t_384;
+        }
+        t_388 = t_385;
+      } else {
+        try {
+          requireInstanceOf__254(codePart_365, CodeRange_105);
+          t_386 = true;
+        } catch {
+          t_386 = false;
+        }
+        if (t_386) {
+          try {
+            t_387 = requireInstanceOf__254(codePart_365, CodeRange_105);
+          } catch {
+            break s_389;
+          }
+          t_377 = t_387.max;
+          t_388 = t_377;
+        } else if (genericEq_57(codePart_365, Digit)) {
+          t_367 = stringCodePoints_8("9");
+          t_378 = t_367.read();
+          t_388 = t_378;
+        } else if (genericEq_57(codePart_365, Space)) {
+          t_368 = stringCodePoints_8(" ");
+          t_379 = t_368.read();
+          t_388 = t_379;
+        } else if (genericEq_57(codePart_365, Word)) {
+          t_369 = stringCodePoints_8("z");
+          t_380 = t_369.read();
+          t_388 = t_380;
+        } else {
+          t_388 = null;
+        }
+      }
+      try {
+        return_366 = t_388;
+        return return_366;
+      } catch {
+      }
+    }
+    throw noResultException__256;
+  }
+  constructor(out_394) {
+    let return_395;
+    let t_396;
+    return_395 = void 0;
+    if (!(out_394 !== void 0)) {
+      t_396 = [];
+      out_394 = t_396;
+    }
+    this.#out_227 = out_394;
+    return;
+  }
+}
+let typePlaceholder_397;
+let typePlaceholder_398;
+function Begin_399(...args_400) {
+  return new Begin_401(...args_400);
+}
+class Begin_401 {
+  constructor() {
+    let return_402;
+    return_402 = void 0;
+    return;
+  }
+}
+Special_70.implementedBy(Begin_401);
+let t_403 = Begin_399();
+export const Begin = t_403;
+;
+function Dot_404(...args_405) {
+  return new Dot_406(...args_405);
+}
+class Dot_406 {
+  constructor() {
+    let return_407;
+    return_407 = void 0;
+    return;
+  }
+}
+Special_70.implementedBy(Dot_406);
+let t_408 = Dot_404();
+export const Dot = t_408;
+;
+function End_409(...args_410) {
+  return new End_411(...args_410);
+}
+class End_411 {
+  constructor() {
+    let return_412;
+    return_412 = void 0;
+    return;
+  }
+}
+Special_70.implementedBy(End_411);
+let t_413 = End_409();
+export const End = t_413;
+;
+function WordBoundary_414(...args_415) {
+  return new WordBoundary_416(...args_415);
+}
+class WordBoundary_416 {
+  constructor() {
+    let return_417;
+    return_417 = void 0;
+    return;
+  }
+}
+Special_70.implementedBy(WordBoundary_416);
+let t_418 = WordBoundary_414();
+export const WordBoundary = t_418;
+;
+let typePlaceholder_419;
+function Digit_420(...args_421) {
+  return new Digit_422(...args_421);
+}
+class Digit_422 {
+  constructor() {
+    let return_423;
+    return_423 = void 0;
+    return;
+  }
+}
+SpecialSet_72.implementedBy(Digit_422);
+let t_424 = Digit_420();
+export const Digit = t_424;
+;
+function Space_425(...args_426) {
+  return new Space_427(...args_426);
+}
+class Space_427 {
+  constructor() {
+    let return_428;
+    return_428 = void 0;
+    return;
+  }
+}
+SpecialSet_72.implementedBy(Space_427);
+let t_429 = Space_425();
+export const Space = t_429;
+;
+function Word_430(...args_431) {
+  return new Word_432(...args_431);
+}
+class Word_432 {
+  constructor() {
+    let return_433;
+    return_433 = void 0;
+    return;
+  }
+}
+SpecialSet_72.implementedBy(Word_432);
+let t_434 = Word_430();
+export const Word = t_434;
+;
+export function entire(item_435) {
+  let return_436;
+  let t_437 = Sequence(listify_52(Begin, item_435, End));
+  return_436 = t_437;
+  return return_436;
+};
+export function oneOrMore(item_438, reluctant_439) {
+  let return_440;
+  if (!(reluctant_439 !== void 0)) {
+    reluctant_439 = false;
+  }
+  let t_441 = Repeat(item_438, 1, null, reluctant_439);
+  return_440 = t_441;
+  return return_440;
+};
+export function optional(item_442, reluctant_443) {
+  let return_444;
+  if (!(reluctant_443 !== void 0)) {
+    reluctant_443 = false;
+  }
+  let t_445 = Repeat(item_442, 0, 1, reluctant_443);
+  return_444 = t_445;
+  return return_444;
+};
+let t_446 = RegexRefs_181();
+const regexRefs_217 = t_446;
+const return_447 = RegexFormatter_221;
+export default return_447;
+export {
+  InterfaceType_51
+};