@attocash/commons-js 5.0.0

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/internal/format/FormatStructure.mjs

@@ -0,0 +1,698 @@
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  equals2au1ep9vhcato as equals,
+  hashCodeq5arwsb9dgti as hashCode,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charCodeAt1yspne1d8erbm as charCodeAt,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/charSequenceJs.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { isAsciiDigit3p3aq858xklh as isAsciiDigit } from '../util.mjs';
+import {
+  substringiqarkczpya5m as substring,
+  substring3saq8ornu0luv as substring_0,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/text/stringJs.mjs';
+import { ConstantNumberConsumer1fkn3mtvfbopz as ConstantNumberConsumer } from './parser/NumberConsumer.mjs';
+import { listOfvhqybd2zx248 as listOf } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import {
+  NumberSpanParserOperation3qyp02c4km7yu as NumberSpanParserOperation,
+  PlainStringParserOperation3o6zmwb0f0e6n as PlainStringParserOperation,
+  SignParserj94qlnys16wg as SignParser,
+  UnconditionalModification151pp4lqfue9i as UnconditionalModification,
+} from './parser/ParserOperation.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { get_lastIndexld83bqhfgcdd as get_lastIndex } from '../../../../../kotlin-kotlin-stdlib/kotlin/text/Strings.mjs';
+import {
+  emptyList1g2z5xcrvp2zy as emptyList,
+  listOf1jh22dvmctj1r as listOf_0,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import {
+  ParserStructure2cqp7gjft5io4 as ParserStructure,
+  concat2z827ubu7ap26 as concat,
+} from './parser/Parser.mjs';
+import { ConstantStringFormatterStructure25vvm6os5tq8f as ConstantStringFormatterStructure } from './formatter/FormatterOperation.mjs';
+import {
+  toSet2orjxp16sotqu as toSet,
+  distinct10qe1scfdvu5k as distinct,
+  joinToString1cxrrlmo0chqs as joinToString,
+  singleo93pzdgfc557 as single,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  SignedFormatter14cujr8xyyuqw as SignedFormatter,
+  ConditionalFormatter2qfqdnibwbifo as ConditionalFormatter,
+  ConcatenatedFormattergumn65iplrh1 as ConcatenatedFormatter,
+} from './formatter/Formatter.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import {
+  ComparisonPredicate21wq2zjdls3fu as ComparisonPredicate,
+  conjunctionPredicate3qd2h4fxtw47e as conjunctionPredicate,
+  Truth_instanceh2d1wku1pkam as Truth_instance,
+  Truth1p2zb9jq6ku60 as Truth,
+} from './Predicate.mjs';
+import { to2cs3ny02qtbcb as to } from '../../../../../kotlin-kotlin-stdlib/kotlin/Tuples.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var CachedFormatStructureClass;
+function CachedFormatStructure() {
+  if (CachedFormatStructureClass === VOID) {
+    class $ extends ConcatenatedFormatStructure() {
+      constructor(formats) {
+        super(formats);
+        this.l1l_1 = super.q1m();
+        this.m1l_1 = super.n1l();
+      }
+      q1m() {
+        return this.l1l_1;
+      }
+      n1l() {
+        return this.m1l_1;
+      }
+    }
+    initMetadataForClass($, 'CachedFormatStructure');
+    CachedFormatStructureClass = $;
+  }
+  return CachedFormatStructureClass;
+}
+var BasicFormatStructureClass;
+function BasicFormatStructure() {
+  if (BasicFormatStructureClass === VOID) {
+    class $ {
+      constructor(directive) {
+        this.j1r_1 = directive;
+      }
+      toString() {
+        return 'BasicFormatStructure(' + toString(this.j1r_1) + ')';
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof BasicFormatStructure()) {
+          tmp = equals(this.j1r_1, other.j1r_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.j1r_1);
+      }
+      n1l() {
+        return this.j1r_1.n1l();
+      }
+      q1m() {
+        return this.j1r_1.q1m();
+      }
+    }
+    initMetadataForClass($, 'BasicFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure()]);
+    BasicFormatStructureClass = $;
+  }
+  return BasicFormatStructureClass;
+}
+var ConstantFormatStructureClass;
+function ConstantFormatStructure() {
+  if (ConstantFormatStructureClass === VOID) {
+    class $ {
+      constructor(string) {
+        this.k1r_1 = string;
+      }
+      toString() {
+        return 'ConstantFormatStructure(' + this.k1r_1 + ')';
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof ConstantFormatStructure()) {
+          tmp = this.k1r_1 === other.k1r_1;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return getStringHashCode(this.k1r_1);
+      }
+      n1l() {
+        var tmp;
+        // Inline function 'kotlin.text.isEmpty' call
+        var this_0 = this.k1r_1;
+        if (charSequenceLength(this_0) === 0) {
+          tmp = emptyList();
+        } else {
+          // Inline function 'kotlin.collections.buildList' call
+          // Inline function 'kotlin.collections.buildListInternal' call
+          // Inline function 'kotlin.apply' call
+          var this_1 = ArrayList().l1();
+          var tmp_0;
+          if (isAsciiDigit(charCodeAt(this.k1r_1, 0))) {
+            var tmp0 = this.k1r_1;
+            var tmp$ret$2;
+            $l$block: {
+              // Inline function 'kotlin.text.takeWhile' call
+              var inductionVariable = 0;
+              var last = tmp0.length;
+              if (inductionVariable < last)
+                do {
+                  var index = inductionVariable;
+                  inductionVariable = inductionVariable + 1 | 0;
+                  var it = charCodeAt(tmp0, index);
+                  if (!isAsciiDigit(it)) {
+                    tmp$ret$2 = substring(tmp0, 0, index);
+                    break $l$block;
+                  }
+                }
+                 while (inductionVariable < last);
+              tmp$ret$2 = tmp0;
+            }
+            this_1.m(new (NumberSpanParserOperation())(listOf(new (ConstantNumberConsumer())(tmp$ret$2))));
+            var tmp0_0 = this.k1r_1;
+            var tmp$ret$4;
+            $l$block_0: {
+              // Inline function 'kotlin.text.dropWhile' call
+              var inductionVariable_0 = 0;
+              var last_0 = charSequenceLength(tmp0_0) - 1 | 0;
+              if (inductionVariable_0 <= last_0)
+                do {
+                  var index_0 = inductionVariable_0;
+                  inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                  var it_0 = charCodeAt(tmp0_0, index_0);
+                  if (!isAsciiDigit(it_0)) {
+                    tmp$ret$4 = substring_0(tmp0_0, index_0);
+                    break $l$block_0;
+                  }
+                }
+                 while (inductionVariable_0 <= last_0);
+              tmp$ret$4 = '';
+            }
+            tmp_0 = tmp$ret$4;
+          } else {
+            tmp_0 = this.k1r_1;
+          }
+          var suffix = tmp_0;
+          // Inline function 'kotlin.text.isNotEmpty' call
+          if (charSequenceLength(suffix) > 0) {
+            if (isAsciiDigit(charCodeAt(suffix, suffix.length - 1 | 0))) {
+              var tmp$ret$7;
+              $l$block_1: {
+                // Inline function 'kotlin.text.dropLastWhile' call
+                var inductionVariable_1 = get_lastIndex(suffix);
+                if (0 <= inductionVariable_1)
+                  do {
+                    var index_1 = inductionVariable_1;
+                    inductionVariable_1 = inductionVariable_1 + -1 | 0;
+                    var it_1 = charCodeAt(suffix, index_1);
+                    if (!isAsciiDigit(it_1)) {
+                      tmp$ret$7 = substring(suffix, 0, index_1 + 1 | 0);
+                      break $l$block_1;
+                    }
+                  }
+                   while (0 <= inductionVariable_1);
+                tmp$ret$7 = '';
+              }
+              this_1.m(new (PlainStringParserOperation())(tmp$ret$7));
+              var tmp$ret$9;
+              $l$block_2: {
+                // Inline function 'kotlin.text.takeLastWhile' call
+                var inductionVariable_2 = get_lastIndex(suffix);
+                if (0 <= inductionVariable_2)
+                  do {
+                    var index_2 = inductionVariable_2;
+                    inductionVariable_2 = inductionVariable_2 + -1 | 0;
+                    var it_2 = charCodeAt(suffix, index_2);
+                    if (!isAsciiDigit(it_2)) {
+                      tmp$ret$9 = substring_0(suffix, index_2 + 1 | 0);
+                      break $l$block_2;
+                    }
+                  }
+                   while (0 <= inductionVariable_2);
+                tmp$ret$9 = suffix;
+              }
+              this_1.m(new (NumberSpanParserOperation())(listOf(new (ConstantNumberConsumer())(tmp$ret$9))));
+            } else {
+              this_1.m(new (PlainStringParserOperation())(suffix));
+            }
+          }
+          tmp = this_1.p7();
+        }
+        return new (ParserStructure())(tmp, emptyList());
+      }
+      q1m() {
+        return new (ConstantStringFormatterStructure())(this.k1r_1);
+      }
+    }
+    initMetadataForClass($, 'ConstantFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure()]);
+    ConstantFormatStructureClass = $;
+  }
+  return ConstantFormatStructureClass;
+}
+function formatter$checkIfAllNegative(this$0, value) {
+  var seenNonZero = false;
+  var tmp0_iterator = this$0.n1r_1.d1();
+  $l$loop: while (tmp0_iterator.e1()) {
+    var check = tmp0_iterator.f1();
+    if (check.z1h().i1r(value) === true)
+      seenNonZero = true;
+    else if (check.d1q(value))
+      continue $l$loop;
+    else
+      return false;
+  }
+  return seenNonZero;
+}
+function SignedFormatStructure$parser$lambda(this$0) {
+  return function (value, isNegative) {
+    var tmp0_iterator = this$0.n1r_1.d1();
+    while (tmp0_iterator.e1()) {
+      var field = tmp0_iterator.f1();
+      var wasNegative = field.z1h().i1r(value) === true;
+      field.z1h().z1q(value, !(isNegative === wasNegative));
+    }
+    return Unit_instance;
+  };
+}
+function SignedFormatStructure$formatter$checkIfAllNegative$ref(this$0) {
+  var l = function (p0) {
+    return formatter$checkIfAllNegative(this$0, p0);
+  };
+  l.callableName = 'checkIfAllNegative';
+  return l;
+}
+var SignedFormatStructureClass;
+function SignedFormatStructure() {
+  if (SignedFormatStructureClass === VOID) {
+    class $ {
+      constructor(format, withPlusSign) {
+        this.l1r_1 = format;
+        this.m1r_1 = withPlusSign;
+        var tmp = this;
+        // Inline function 'kotlin.collections.mapNotNull' call
+        var tmp0 = basicFormats(this.l1r_1);
+        // Inline function 'kotlin.collections.mapNotNullTo' call
+        var destination = ArrayList().l1();
+        // Inline function 'kotlin.collections.forEach' call
+        var _iterator__ex2g4s = tmp0.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var element = _iterator__ex2g4s.f1();
+          var tmp0_safe_receiver = element.p1m().f1r();
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            // Inline function 'kotlin.let' call
+            destination.m(tmp0_safe_receiver);
+          }
+        }
+        tmp.n1r_1 = toSet(destination);
+        // Inline function 'kotlin.collections.isNotEmpty' call
+        // Inline function 'kotlin.require' call
+        if (!!this.n1r_1.j()) {
+          var message = 'Signed format must contain at least one field with a sign';
+          throw IllegalArgumentException().u(toString(message));
+        }
+      }
+      toString() {
+        return 'SignedFormatStructure(' + toString(this.l1r_1) + ')';
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        if (other instanceof SignedFormatStructure()) {
+          tmp_0 = equals(this.l1r_1, other.l1r_1);
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = this.m1r_1 === other.m1r_1;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return imul(31, hashCode(this.l1r_1)) + getBooleanHashCode(this.m1r_1) | 0;
+      }
+      n1l() {
+        return concat(listOf_0([new (ParserStructure())(listOf(new (SignParser())(SignedFormatStructure$parser$lambda(this), this.m1r_1, 'sign for ' + toString(this.n1r_1))), emptyList()), this.l1r_1.n1l()]));
+      }
+      q1m() {
+        var innerFormat = this.l1r_1.q1m();
+        return new (SignedFormatter())(innerFormat, SignedFormatStructure$formatter$checkIfAllNegative$ref(this), this.m1r_1);
+      }
+    }
+    initMetadataForClass($, 'SignedFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure()]);
+    SignedFormatStructureClass = $;
+  }
+  return SignedFormatStructureClass;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      o1r(field) {
+        var default_0 = field.e1r();
+        // Inline function 'kotlin.require' call
+        if (!!(default_0 == null)) {
+          var message = "The field '" + field.i3() + "' does not define a default value";
+          throw IllegalArgumentException().u(toString(message));
+        }
+        return new (PropertyWithDefault())(field.p1q(), default_0);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+var PropertyWithDefaultClass;
+function PropertyWithDefault() {
+  if (PropertyWithDefaultClass === VOID) {
+    class $ {
+      constructor(accessor, defaultValue) {
+        this.p1r_1 = accessor;
+        this.q1r_1 = defaultValue;
+      }
+    }
+    initMetadataForClass($, 'PropertyWithDefault');
+    PropertyWithDefaultClass = $;
+  }
+  return PropertyWithDefaultClass;
+}
+function OptionalFormatStructure$parser$lambda(this$0) {
+  return function (it) {
+    var tmp0_iterator = this$0.t1r_1.d1();
+    while (tmp0_iterator.e1()) {
+      var field = tmp0_iterator.f1();
+      // Inline function 'kotlinx.datetime.internal.format.PropertyWithDefault.assignDefault' call
+      field.p1r_1.z1q(it, field.q1r_1);
+    }
+    return Unit_instance;
+  };
+}
+function Accessor$getter$ref(p0) {
+  var l = function (_this__u8e3s4) {
+    return p0.i1r(_this__u8e3s4);
+  };
+  l.callableName = 'getter';
+  return l;
+}
+function Predicate$test$ref(p0) {
+  var l = function (_this__u8e3s4) {
+    return p0.u1r(_this__u8e3s4);
+  };
+  l.callableName = 'test';
+  return l;
+}
+function Truth$test$ref(p0) {
+  var l = function (_this__u8e3s4) {
+    return p0.v1r(_this__u8e3s4);
+  };
+  l.callableName = 'test';
+  return l;
+}
+var OptionalFormatStructureClass;
+function OptionalFormatStructure() {
+  if (OptionalFormatStructureClass === VOID) {
+    class $ {
+      constructor(onZero, format) {
+        this.r1r_1 = onZero;
+        this.s1r_1 = format;
+        var tmp = this;
+        // Inline function 'kotlin.collections.map' call
+        var this_0 = basicFormats(this.s1r_1);
+        // Inline function 'kotlin.collections.mapTo' call
+        var destination = ArrayList().c1(collectionSizeOrDefault(this_0, 10));
+        var _iterator__ex2g4s = this_0.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var item = _iterator__ex2g4s.f1();
+          var tmp$ret$0 = item.p1m();
+          destination.m(tmp$ret$0);
+        }
+        // Inline function 'kotlin.collections.map' call
+        var this_1 = distinct(destination);
+        // Inline function 'kotlin.collections.mapTo' call
+        var destination_0 = ArrayList().c1(collectionSizeOrDefault(this_1, 10));
+        var _iterator__ex2g4s_0 = this_1.d1();
+        while (_iterator__ex2g4s_0.e1()) {
+          var item_0 = _iterator__ex2g4s_0.f1();
+          var tmp$ret$3 = Companion_instance.o1r(item_0);
+          destination_0.m(tmp$ret$3);
+        }
+        tmp.t1r_1 = destination_0;
+      }
+      toString() {
+        return 'Optional(' + this.r1r_1 + ', ' + toString(this.s1r_1) + ')';
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        if (other instanceof OptionalFormatStructure()) {
+          tmp_0 = this.r1r_1 === other.r1r_1;
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = equals(this.s1r_1, other.s1r_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return imul(31, getStringHashCode(this.r1r_1)) + hashCode(this.s1r_1) | 0;
+      }
+      n1l() {
+        var tmp = emptyList();
+        var tmp_0 = this.s1r_1.n1l();
+        var tmp_1 = (new (ConstantFormatStructure())(this.r1r_1)).n1l();
+        var tmp_2;
+        if (this.t1r_1.j()) {
+          tmp_2 = emptyList();
+        } else {
+          tmp_2 = listOf(new (UnconditionalModification())(OptionalFormatStructure$parser$lambda(this)));
+        }
+        return new (ParserStructure())(tmp, listOf_0([tmp_0, concat(listOf_0([tmp_1, new (ParserStructure())(tmp_2, emptyList())]))]));
+      }
+      q1m() {
+        var formatter = this.s1r_1.q1m();
+        // Inline function 'kotlin.collections.map' call
+        var this_0 = this.t1r_1;
+        // Inline function 'kotlin.collections.mapTo' call
+        var destination = ArrayList().c1(collectionSizeOrDefault(this_0, 10));
+        var _iterator__ex2g4s = this_0.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var item = _iterator__ex2g4s.f1();
+          // Inline function 'kotlinx.datetime.internal.format.PropertyWithDefault.isDefaultComparisonPredicate' call
+          var tmp$ret$1 = new (ComparisonPredicate())(item.q1r_1, Accessor$getter$ref(item.p1r_1));
+          destination.m(tmp$ret$1);
+        }
+        var predicate = conjunctionPredicate(destination);
+        var tmp;
+        if (predicate instanceof Truth()) {
+          tmp = new (ConstantStringFormatterStructure())(this.r1r_1);
+        } else {
+          var tmp_0 = to(Predicate$test$ref(predicate), new (ConstantStringFormatterStructure())(this.r1r_1));
+          tmp = new (ConditionalFormatter())(listOf_0([tmp_0, to(Truth$test$ref(Truth_instance), formatter)]));
+        }
+        return tmp;
+      }
+    }
+    initMetadataForClass($, 'OptionalFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure()]);
+    OptionalFormatStructureClass = $;
+  }
+  return OptionalFormatStructureClass;
+}
+var AlternativesParsingFormatStructureClass;
+function AlternativesParsingFormatStructure() {
+  if (AlternativesParsingFormatStructureClass === VOID) {
+    class $ {
+      constructor(mainFormat, formats) {
+        this.w1r_1 = mainFormat;
+        this.x1r_1 = formats;
+      }
+      toString() {
+        return 'AlternativesParsing(' + toString(this.x1r_1) + ')';
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        if (other instanceof AlternativesParsingFormatStructure()) {
+          tmp_0 = equals(this.w1r_1, other.w1r_1);
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = equals(this.x1r_1, other.x1r_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return imul(31, hashCode(this.w1r_1)) + hashCode(this.x1r_1) | 0;
+      }
+      n1l() {
+        var tmp = emptyList();
+        // Inline function 'kotlin.collections.buildList' call
+        // Inline function 'kotlin.collections.buildListInternal' call
+        // Inline function 'kotlin.apply' call
+        var this_0 = ArrayList().l1();
+        this_0.m(this.w1r_1.n1l());
+        var tmp0_iterator = this.x1r_1.d1();
+        while (tmp0_iterator.e1()) {
+          var format = tmp0_iterator.f1();
+          this_0.m(format.n1l());
+        }
+        var tmp$ret$3 = this_0.p7();
+        return new (ParserStructure())(tmp, tmp$ret$3);
+      }
+      q1m() {
+        return this.w1r_1.q1m();
+      }
+    }
+    initMetadataForClass($, 'AlternativesParsingFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure()]);
+    AlternativesParsingFormatStructureClass = $;
+  }
+  return AlternativesParsingFormatStructureClass;
+}
+var ConcatenatedFormatStructureClass;
+function ConcatenatedFormatStructure() {
+  if (ConcatenatedFormatStructureClass === VOID) {
+    class $ {
+      constructor(formats) {
+        this.o1l_1 = formats;
+      }
+      toString() {
+        return 'ConcatenatedFormatStructure(' + joinToString(this.o1l_1, ', ') + ')';
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof ConcatenatedFormatStructure()) {
+          tmp = equals(this.o1l_1, other.o1l_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.o1l_1);
+      }
+      n1l() {
+        // Inline function 'kotlin.collections.map' call
+        var this_0 = this.o1l_1;
+        // Inline function 'kotlin.collections.mapTo' call
+        var destination = ArrayList().c1(collectionSizeOrDefault(this_0, 10));
+        var _iterator__ex2g4s = this_0.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var item = _iterator__ex2g4s.f1();
+          var tmp$ret$0 = item.n1l();
+          destination.m(tmp$ret$0);
+        }
+        return concat(destination);
+      }
+      q1m() {
+        // Inline function 'kotlin.collections.map' call
+        var this_0 = this.o1l_1;
+        // Inline function 'kotlin.collections.mapTo' call
+        var destination = ArrayList().c1(collectionSizeOrDefault(this_0, 10));
+        var _iterator__ex2g4s = this_0.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var item = _iterator__ex2g4s.f1();
+          var tmp$ret$0 = item.q1m();
+          destination.m(tmp$ret$0);
+        }
+        var formatters = destination;
+        var tmp;
+        if (formatters.i1() === 1) {
+          tmp = single(formatters);
+        } else {
+          tmp = new (ConcatenatedFormatter())(formatters);
+        }
+        return tmp;
+      }
+    }
+    initMetadataForClass($, 'ConcatenatedFormatStructure');
+    ConcatenatedFormatStructureClass = $;
+  }
+  return ConcatenatedFormatStructureClass;
+}
+var NonConcatenatedFormatStructureClass;
+function NonConcatenatedFormatStructure() {
+  if (NonConcatenatedFormatStructureClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'NonConcatenatedFormatStructure');
+    NonConcatenatedFormatStructureClass = $;
+  }
+  return NonConcatenatedFormatStructureClass;
+}
+function basicFormats(format) {
+  // Inline function 'kotlin.collections.buildList' call
+  // Inline function 'kotlin.collections.buildListInternal' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = ArrayList().l1();
+  basicFormats$_anonymous_$rec_hkf0lf(this_0, format);
+  return this_0.p7();
+}
+function basicFormats$_anonymous_$rec_hkf0lf($this_buildList, format) {
+  if (format instanceof BasicFormatStructure()) {
+    $this_buildList.m(format.j1r_1);
+  } else {
+    if (format instanceof ConcatenatedFormatStructure()) {
+      // Inline function 'kotlin.collections.forEach' call
+      var _iterator__ex2g4s = format.o1l_1.d1();
+      while (_iterator__ex2g4s.e1()) {
+        var element = _iterator__ex2g4s.f1();
+        basicFormats$_anonymous_$rec_hkf0lf($this_buildList, element);
+      }
+    } else {
+      if (!(format instanceof ConstantFormatStructure())) {
+        if (format instanceof SignedFormatStructure()) {
+          basicFormats$_anonymous_$rec_hkf0lf($this_buildList, format.l1r_1);
+        } else {
+          if (format instanceof AlternativesParsingFormatStructure()) {
+            basicFormats$_anonymous_$rec_hkf0lf($this_buildList, format.w1r_1);
+            // Inline function 'kotlin.collections.forEach' call
+            var _iterator__ex2g4s_0 = format.x1r_1.d1();
+            while (_iterator__ex2g4s_0.e1()) {
+              var element_0 = _iterator__ex2g4s_0.f1();
+              basicFormats$_anonymous_$rec_hkf0lf($this_buildList, element_0);
+            }
+          } else {
+            if (format instanceof OptionalFormatStructure()) {
+              basicFormats$_anonymous_$rec_hkf0lf($this_buildList, format.s1r_1);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  AlternativesParsingFormatStructure as AlternativesParsingFormatStructure1jbxrbmj8ihe6,
+  BasicFormatStructure as BasicFormatStructure1rp1tyv3u2fjw,
+  CachedFormatStructure as CachedFormatStructurec5vu2vku3yjz,
+  ConcatenatedFormatStructure as ConcatenatedFormatStructure27s7lx6ixzw2f,
+  ConstantFormatStructure as ConstantFormatStructure2ckhnu4xssh81,
+  NonConcatenatedFormatStructure as NonConcatenatedFormatStructure1tep5eavrzcwp,
+  OptionalFormatStructure as OptionalFormatStructure1lur7h5l20ekc,
+  SignedFormatStructure as SignedFormatStructure3e3cmtnnik1yf,
+};
+//endregion
+
+//# sourceMappingURL=FormatStructure.mjs.map