@dhis2/expression-parser 1.1.5 → 1.1.7

package/Kotlin-DateTime-library-kotlinx-datetime.mjs

@@ -0,0 +1,2620 @@
+import {
+  LocalDate as LocalDate,
+  ChronoUnit as ChronoUnit,
+  LocalDateTime as LocalDateTime,
+  ZoneOffset as ZoneOffset,
+  ZoneId as ZoneId,
+} from '@js-joda/core';
+import {
+  VOID7hggqo3abtya as VOID,
+  protoOf180f3jzyo7rfj as protoOf,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  Long2qws0ah9gnpki as Long,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  toLongw1zpgk99d84b as toLong,
+  StringBuilder_init_$Create$zzhi687lupah as StringBuilder_init_$Create$,
+  _Char___init__impl__6a9atx367vrx0avsvbg as _Char___init__impl__6a9atx,
+  Unit_instanceat14thlj150z as Unit_instance,
+  abs1kdzbjes1idip as abs,
+  padStart36w1507hs626a as padStart,
+  numberRangeToNumber25vse2rgp6rs8 as numberRangeToNumber,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  ClosedRangehokgr73im9z3 as ClosedRange,
+  isInterface3d6p8outrmvmk as isInterface,
+  contains2c50nlxg7en7o as contains,
+  IllegalArgumentException_init_$Create$sfel9vrfa7w2 as IllegalArgumentException_init_$Create$,
+  toString1pkumu07cwy4m as toString,
+  IllegalArgumentException_init_$Init$mo9ojkj6lifc as IllegalArgumentException_init_$Init$,
+  captureStack1fzi4aczwc4hg as captureStack,
+  IllegalArgumentException_init_$Init$3lxmt2zohthr0 as IllegalArgumentException_init_$Init$_0,
+  IllegalArgumentException_init_$Init$35y4bla3jh0vq as IllegalArgumentException_init_$Init$_1,
+  IllegalArgumentException_init_$Init$1b20duosck2sj as IllegalArgumentException_init_$Init$_2,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  RuntimeException_init_$Init$1hjdw43v0c6o7 as RuntimeException_init_$Init$,
+  RuntimeException_init_$Init$1fn23imlcoxh8 as RuntimeException_init_$Init$_0,
+  RuntimeException1r3t0zl97011n as RuntimeException,
+  Enum3alwj03lh1n41 as Enum,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  toString14fd7g605f91p as toString_0,
+  hashCodeq5arwsb9dgti as hashCode,
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  KProperty02ce7r476m8633 as KProperty0,
+  getPropertyCallableRef1ajb9in178r5r as getPropertyCallableRef,
+  KMutableProperty11e8g1gb0ecb9j as KMutableProperty1,
+  lazy2hsh8ze7j6ikd as lazy,
+  ArrayList_init_$Create$2rimpp4x9tjd3 as ArrayList_init_$Create$,
+  equals2au1ep9vhcato as equals,
+  IllegalStateException_init_$Create$1nm9y6jd3c9iy as IllegalStateException_init_$Create$,
+  toString30pk9tzaqopn as toString_1,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  listOfvhqybd2zx248 as listOf,
+  get_lastIndexld83bqhfgcdd as get_lastIndex,
+  emptyList1g2z5xcrvp2zy as emptyList,
+  joinToString1cxrrlmo0chqs as joinToString,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$3m1kyiqequwm5 as ArrayList_init_$Create$_0,
+  singleo93pzdgfc557 as single,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+  mutableListOf6oorvk2mtdmp as mutableListOf,
+  removeLastOrNull3odnlbetbttd4 as removeLastOrNull,
+  sortWith4fnm6b3vw03s as sortWith,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  Comparator2b3maoeh98xtg as Comparator,
+  compareValues1n2ayl87ihzfk as compareValues,
+  Exceptiondt2hlxn7j7vw as Exception,
+  Exception_init_$Init$3c1h61we8oiuv as Exception_init_$Init$,
+  StringBuilder_init_$Create$1ckbfpj83l95o as StringBuilder_init_$Create$_0,
+  joinTo3lkanfaxbzac2 as joinTo,
+  plus310ted5e4i90h as plus,
+  toMutableList20rdgwi7d3cwi as toMutableList,
+  addAll1k27qatfgp3k5 as addAll,
+  Collection1k04j3hzsbod0 as Collection,
+  firstOrNull1982767dljvdy as firstOrNull,
+  drop3na99dw9feawf as drop,
+  listOf1jh22dvmctj1r as listOf_0,
+  repeat2w4c6j8zoq09o as repeat,
+  checkCountOverflow1ro2fe1r4xvgf as checkCountOverflow,
+  Char__minus_impl_a2frrh15zl6plytfjgc as Char__minus_impl_a2frrh,
+  enumEntries20mr21zbe3az4 as enumEntries,
+  Comparable198qfk8pnblz0 as Comparable,
+  IllegalArgumentException_init_$Create$k1dedwd8uq8o as IllegalArgumentException_init_$Create$_0,
+  numberToInt1ygmcfwhs2fkq as numberToInt,
+} from './kotlin-kotlin-stdlib.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+initMetadataForCompanion(Companion);
+initMetadataForClass(DateTimePeriod, 'DateTimePeriod');
+initMetadataForClass(DatePeriod, 'DatePeriod', DatePeriod_init_$Create$, DateTimePeriod);
+initMetadataForCompanion(Companion_0);
+initMetadataForClass(DateTimeFormatException, 'DateTimeFormatException', DateTimeFormatException_init_$Create$, IllegalArgumentException);
+initMetadataForClass(DateTimeArithmeticException, 'DateTimeArithmeticException', DateTimeArithmeticException_init_$Create$, RuntimeException);
+initMetadataForClass(AbstractDateTimeFormat, 'AbstractDateTimeFormat');
+initMetadataForClass(Padding, 'Padding', VOID, Enum);
+function year$default(padding, $super) {
+  padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+  var tmp;
+  if ($super === VOID) {
+    this.ug(padding);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.ug.call(this, padding);
+  }
+  return tmp;
+}
+function monthNumber$default(padding, $super) {
+  padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+  var tmp;
+  if ($super === VOID) {
+    this.wg(padding);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.wg.call(this, padding);
+  }
+  return tmp;
+}
+function dayOfMonth$default(padding, $super) {
+  padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+  var tmp;
+  if ($super === VOID) {
+    this.yg(padding);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.yg.call(this, padding);
+  }
+  return tmp;
+}
+initMetadataForInterface(WithDate, 'WithDate');
+function chars(value) {
+  return this.bh().dh(new ConstantFormatStructure(value));
+}
+function build() {
+  return new CachedFormatStructure(this.bh().eh().fh_1);
+}
+initMetadataForInterface(AbstractDateTimeFormatBuilder, 'AbstractDateTimeFormatBuilder');
+initMetadataForClass(IncompleteLocalDate, 'IncompleteLocalDate', IncompleteLocalDate);
+initMetadataForCompanion(Companion_1);
+function year(padding) {
+  return this.yh(new BasicFormatStructure(new YearDirective(padding)));
+}
+function monthNumber(padding) {
+  return this.yh(new BasicFormatStructure(new MonthDirective(padding)));
+}
+function dayOfMonth(padding) {
+  return this.yh(new BasicFormatStructure(new DayDirective(padding)));
+}
+initMetadataForInterface(AbstractWithDateBuilder, 'AbstractWithDateBuilder', VOID, VOID, [WithDate]);
+initMetadataForClass(Builder, 'Builder', VOID, VOID, [AbstractDateTimeFormatBuilder, AbstractWithDateBuilder]);
+initMetadataForClass(LocalDateFormat, 'LocalDateFormat', VOID, AbstractDateTimeFormat);
+initMetadataForClass(SignedIntFieldFormatDirective, 'SignedIntFieldFormatDirective');
+initMetadataForClass(YearDirective, 'YearDirective', VOID, SignedIntFieldFormatDirective);
+initMetadataForClass(UnsignedIntFieldFormatDirective, 'UnsignedIntFieldFormatDirective');
+initMetadataForClass(MonthDirective, 'MonthDirective', VOID, UnsignedIntFieldFormatDirective);
+initMetadataForClass(DayDirective, 'DayDirective', VOID, UnsignedIntFieldFormatDirective);
+initMetadataForObject(DateFields, 'DateFields');
+initMetadataForClass(AppendableFormatStructure, 'AppendableFormatStructure', AppendableFormatStructure);
+initMetadataForClass(AbstractFieldSpec, 'AbstractFieldSpec');
+initMetadataForClass(GenericFieldSpec, 'GenericFieldSpec', VOID, AbstractFieldSpec);
+function getterNotNull(container) {
+  var tmp0_elvis_lhs = this.xj(container);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throw IllegalStateException_init_$Create$('Field ' + this.i2() + ' is not set');
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+initMetadataForInterface(Accessor, 'Accessor');
+initMetadataForClass(PropertyAccessor, 'PropertyAccessor', VOID, VOID, [Accessor]);
+initMetadataForClass(UnsignedFieldSpec, 'UnsignedFieldSpec', VOID, AbstractFieldSpec);
+initMetadataForClass(ConcatenatedFormatStructure, 'ConcatenatedFormatStructure');
+initMetadataForClass(CachedFormatStructure, 'CachedFormatStructure', VOID, ConcatenatedFormatStructure);
+initMetadataForInterface(NonConcatenatedFormatStructure, 'NonConcatenatedFormatStructure');
+initMetadataForClass(BasicFormatStructure, 'BasicFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure]);
+initMetadataForClass(ConstantFormatStructure, 'ConstantFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure]);
+initMetadataForClass(SpacePaddedFormatter, 'SpacePaddedFormatter');
+initMetadataForClass(ConcatenatedFormatter, 'ConcatenatedFormatter');
+initMetadataForClass(SignedIntFormatterStructure, 'SignedIntFormatterStructure');
+initMetadataForClass(UnsignedIntFormatterStructure, 'UnsignedIntFormatterStructure');
+initMetadataForClass(ConstantStringFormatterStructure, 'ConstantStringFormatterStructure');
+initMetadataForClass(NumberConsumer, 'NumberConsumer');
+initMetadataForClass(ConstantNumberConsumer, 'ConstantNumberConsumer', VOID, NumberConsumer);
+initMetadataForObject(ExpectedInt, 'ExpectedInt');
+initMetadataForClass(TooManyDigits, 'TooManyDigits');
+initMetadataForClass(TooFewDigits, 'TooFewDigits');
+initMetadataForClass(WrongConstant, 'WrongConstant');
+initMetadataForClass(Conflicting, 'Conflicting');
+initMetadataForClass(UnsignedIntConsumer, 'UnsignedIntConsumer', VOID, NumberConsumer);
+initMetadataForClass(ParseError, 'ParseError');
+initMetadataForCompanion(Companion_2);
+initMetadataForClass(ParserState, 'ParserState');
+initMetadataForClass(sam$kotlin_Comparator$0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+initMetadataForClass(Parser, 'Parser');
+initMetadataForClass(ParserStructure, 'ParserStructure');
+initMetadataForClass(ParseException, 'ParseException', VOID, Exception);
+initMetadataForClass(NumberSpanParserOperation, 'NumberSpanParserOperation');
+initMetadataForClass(PlainStringParserOperation, 'PlainStringParserOperation');
+initMetadataForClass(UnconditionalModification, 'UnconditionalModification');
+initMetadataForClass(DayOfWeek_0, 'DayOfWeek', VOID, Enum);
+initMetadataForClass(Instant, 'Instant', VOID, VOID, [Comparable]);
+initMetadataForCompanion(Companion_3);
+initMetadataForObject(Formats, 'Formats');
+initMetadataForClass(LocalDate_0, 'LocalDate', VOID, VOID, [Comparable]);
+initMetadataForCompanion(Companion_4);
+initMetadataForClass(LocalDateTime_0, 'LocalDateTime', VOID, VOID, [Comparable]);
+initMetadataForCompanion(Companion_5);
+initMetadataForClass(TimeZone, 'TimeZone');
+initMetadataForCompanion(Companion_6);
+initMetadataForClass(FixedOffsetTimeZone, 'FixedOffsetTimeZone', VOID, TimeZone);
+initMetadataForCompanion(Companion_7);
+initMetadataForClass(UtcOffset, 'UtcOffset');
+//endregion
+function DatePeriod_init_$Init$(years, months, days, $this) {
+  years = years === VOID ? 0 : years;
+  months = months === VOID ? 0 : months;
+  days = days === VOID ? 0 : days;
+  DatePeriod.call($this, totalMonths(years, months), days);
+  return $this;
+}
+function DatePeriod_init_$Create$(years, months, days) {
+  return DatePeriod_init_$Init$(years, months, days, objectCreate(protoOf(DatePeriod)));
+}
+function Companion() {
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+function DatePeriod(totalMonths, days) {
+  DateTimePeriod.call(this);
+  this.zf_1 = totalMonths;
+  this.ag_1 = days;
+}
+protoOf(DatePeriod).bg = function () {
+  return this.zf_1;
+};
+protoOf(DatePeriod).cg = function () {
+  return this.ag_1;
+};
+protoOf(DatePeriod).dg = function () {
+  return 0;
+};
+protoOf(DatePeriod).eg = function () {
+  return 0;
+};
+protoOf(DatePeriod).fg = function () {
+  return 0;
+};
+protoOf(DatePeriod).gg = function () {
+  return 0;
+};
+protoOf(DatePeriod).hg = function () {
+  return new Long(0, 0);
+};
+function allNonpositive($this) {
+  return $this.bg() <= 0 && $this.cg() <= 0 && $this.hg().a1(new Long(0, 0)) <= 0 && (!(($this.bg() | $this.cg()) === 0) || !$this.hg().equals(new Long(0, 0)));
+}
+function Companion_0() {
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
+function DateTimePeriod() {
+}
+protoOf(DateTimePeriod).ig = function () {
+  return this.bg() / 12 | 0;
+};
+protoOf(DateTimePeriod).jg = function () {
+  return this.bg() % 12 | 0;
+};
+protoOf(DateTimePeriod).dg = function () {
+  return this.hg().s2(new Long(817405952, 838)).z();
+};
+protoOf(DateTimePeriod).eg = function () {
+  return this.hg().t2(new Long(817405952, 838)).s2(new Long(-129542144, 13)).z();
+};
+protoOf(DateTimePeriod).fg = function () {
+  // Inline function 'kotlin.Long.div' call
+  var this_0 = this.hg().t2(new Long(-129542144, 13));
+  var other = 1000000000;
+  return this_0.s2(toLong(other)).z();
+};
+protoOf(DateTimePeriod).gg = function () {
+  // Inline function 'kotlin.Long.rem' call
+  var this_0 = this.hg();
+  var other = 1000000000;
+  return this_0.t2(toLong(other)).z();
+};
+protoOf(DateTimePeriod).toString = function () {
+  // Inline function 'kotlin.text.buildString' call
+  // Inline function 'kotlin.contracts.contract' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = StringBuilder_init_$Create$();
+  // Inline function 'kotlin.contracts.contract' call
+  // Inline function 'kotlinx.datetime.DateTimePeriod.toString.<anonymous>' call
+  var tmp;
+  if (allNonpositive(this)) {
+    this_0.i7(_Char___init__impl__6a9atx(45));
+    tmp = -1;
+  } else {
+    tmp = 1;
+  }
+  var sign = tmp;
+  this_0.i7(_Char___init__impl__6a9atx(80));
+  if (!(this.ig() === 0)) {
+    this_0.ga(imul(this.ig(), sign)).i7(_Char___init__impl__6a9atx(89));
+  }
+  if (!(this.jg() === 0)) {
+    this_0.ga(imul(this.jg(), sign)).i7(_Char___init__impl__6a9atx(77));
+  }
+  if (!(this.cg() === 0)) {
+    this_0.ga(imul(this.cg(), sign)).i7(_Char___init__impl__6a9atx(68));
+  }
+  var t = 'T';
+  if (!(this.dg() === 0)) {
+    // Inline function 'kotlin.also' call
+    this_0.h7(t).ga(imul(this.dg(), sign)).i7(_Char___init__impl__6a9atx(72));
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.DateTimePeriod.toString.<anonymous>.<anonymous>' call
+    t = '';
+  }
+  if (!(this.eg() === 0)) {
+    // Inline function 'kotlin.also' call
+    this_0.h7(t).ga(imul(this.eg(), sign)).i7(_Char___init__impl__6a9atx(77));
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.DateTimePeriod.toString.<anonymous>.<anonymous>' call
+    t = '';
+  }
+  if (!((this.fg() | this.gg()) === 0)) {
+    this_0.h7(t);
+    this_0.g7(!(this.fg() === 0) ? imul(this.fg(), sign) : imul(this.gg(), sign) < 0 ? '-0' : '0');
+    if (!(this.gg() === 0)) {
+      var tmp_0 = this_0.i7(_Char___init__impl__6a9atx(46));
+      // Inline function 'kotlin.math.absoluteValue' call
+      var this_1 = this.gg();
+      var tmp$ret$2 = abs(this_1);
+      tmp_0.h7(padStart(tmp$ret$2.toString(), 9, _Char___init__impl__6a9atx(48)));
+    }
+    this_0.i7(_Char___init__impl__6a9atx(83));
+  }
+  if (this_0.a() === 1) {
+    this_0.h7('0D');
+  }
+  return this_0.toString();
+};
+protoOf(DateTimePeriod).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof DateTimePeriod))
+    return false;
+  if (!(this.bg() === other.bg()))
+    return false;
+  if (!(this.cg() === other.cg()))
+    return false;
+  if (!this.hg().equals(other.hg()))
+    return false;
+  return true;
+};
+protoOf(DateTimePeriod).hashCode = function () {
+  var result = this.bg();
+  result = imul(31, result) + this.cg() | 0;
+  result = imul(31, result) + this.hg().hashCode() | 0;
+  return result;
+};
+function totalMonths(years, months) {
+  // Inline function 'kotlin.Long.times' call
+  var totalMonths = toLong(years).r2(toLong(12)).p2(toLong(months));
+  var tmp;
+  // Inline function 'kotlin.ranges.contains' call
+  var this_0 = numberRangeToNumber(-2147483648, 2147483647);
+  if (contains(isInterface(this_0, ClosedRange) ? this_0 : THROW_CCE(), totalMonths)) {
+    tmp = totalMonths.z();
+  } else {
+    throw IllegalArgumentException_init_$Create$('The total number of months in ' + years + ' years and ' + months + ' months overflows an Int');
+  }
+  return tmp;
+}
+function get_isoDayNumber(_this__u8e3s4) {
+  return _this__u8e3s4.h2_1 + 1 | 0;
+}
+function DayOfWeek(isoDayNumber) {
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(1 <= isoDayNumber ? isoDayNumber <= 7 : false)) {
+    // Inline function 'kotlinx.datetime.DayOfWeek.<anonymous>' call
+    var message = 'Expected ISO day-of-week number in 1..7, got ' + isoDayNumber;
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  return get_entries().n(isoDayNumber - 1 | 0);
+}
+function DateTimeFormatException_init_$Init$($this) {
+  IllegalArgumentException_init_$Init$($this);
+  DateTimeFormatException.call($this);
+  return $this;
+}
+function DateTimeFormatException_init_$Create$() {
+  var tmp = DateTimeFormatException_init_$Init$(objectCreate(protoOf(DateTimeFormatException)));
+  captureStack(tmp, DateTimeFormatException_init_$Create$);
+  return tmp;
+}
+function DateTimeFormatException_init_$Init$_0(message, $this) {
+  IllegalArgumentException_init_$Init$_0(message, $this);
+  DateTimeFormatException.call($this);
+  return $this;
+}
+function DateTimeFormatException_init_$Create$_0(message) {
+  var tmp = DateTimeFormatException_init_$Init$_0(message, objectCreate(protoOf(DateTimeFormatException)));
+  captureStack(tmp, DateTimeFormatException_init_$Create$_0);
+  return tmp;
+}
+function DateTimeFormatException_init_$Init$_1(cause, $this) {
+  IllegalArgumentException_init_$Init$_1(cause, $this);
+  DateTimeFormatException.call($this);
+  return $this;
+}
+function DateTimeFormatException_init_$Create$_1(cause) {
+  var tmp = DateTimeFormatException_init_$Init$_1(cause, objectCreate(protoOf(DateTimeFormatException)));
+  captureStack(tmp, DateTimeFormatException_init_$Create$_1);
+  return tmp;
+}
+function DateTimeFormatException_init_$Init$_2(message, cause, $this) {
+  IllegalArgumentException_init_$Init$_2(message, cause, $this);
+  DateTimeFormatException.call($this);
+  return $this;
+}
+function DateTimeFormatException_init_$Create$_2(message, cause) {
+  var tmp = DateTimeFormatException_init_$Init$_2(message, cause, objectCreate(protoOf(DateTimeFormatException)));
+  captureStack(tmp, DateTimeFormatException_init_$Create$_2);
+  return tmp;
+}
+function DateTimeFormatException() {
+  captureStack(this, DateTimeFormatException);
+}
+function DateTimeArithmeticException_init_$Init$($this) {
+  RuntimeException_init_$Init$($this);
+  DateTimeArithmeticException.call($this);
+  return $this;
+}
+function DateTimeArithmeticException_init_$Create$() {
+  var tmp = DateTimeArithmeticException_init_$Init$(objectCreate(protoOf(DateTimeArithmeticException)));
+  captureStack(tmp, DateTimeArithmeticException_init_$Create$);
+  return tmp;
+}
+function DateTimeArithmeticException_init_$Init$_0(cause, $this) {
+  RuntimeException_init_$Init$_0(cause, $this);
+  DateTimeArithmeticException.call($this);
+  return $this;
+}
+function DateTimeArithmeticException_init_$Create$_0(cause) {
+  var tmp = DateTimeArithmeticException_init_$Init$_0(cause, objectCreate(protoOf(DateTimeArithmeticException)));
+  captureStack(tmp, DateTimeArithmeticException_init_$Create$_0);
+  return tmp;
+}
+function DateTimeArithmeticException() {
+  captureStack(this, DateTimeArithmeticException);
+}
+function getIsoDateFormat() {
+  return Formats_getInstance().lg();
+}
+function asTimeZone(_this__u8e3s4) {
+  return FixedOffsetTimeZone_init_$Create$(_this__u8e3s4);
+}
+function AbstractDateTimeFormat() {
+}
+protoOf(AbstractDateTimeFormat).pg = function (input) {
+  var tmp;
+  try {
+    tmp = Parser__match$default_impl_x2xlti(_Parser___init__impl__gdyfby(this.mg().tg()), input, this.og());
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof ParseException) {
+      var e = $p;
+      throw DateTimeFormatException_init_$Create$_2("Failed to parse value from '" + toString(input) + "'", e);
+    } else {
+      throw $p;
+    }
+  }
+  var matched = tmp;
+  try {
+    return this.ng(matched);
+  } catch ($p) {
+    if ($p instanceof IllegalArgumentException) {
+      var e_0 = $p;
+      var message = e_0.message;
+      throw DateTimeFormatException_init_$Create$_2(message == null ? "The value parsed from '" + toString(input) + "' is invalid" : '' + message + " (when parsing '" + toString(input) + "')", e_0);
+    } else {
+      throw $p;
+    }
+  }
+};
+var Padding_NONE_instance;
+var Padding_ZERO_instance;
+var Padding_SPACE_instance;
+var Padding_entriesInitialized;
+function Padding_initEntries() {
+  if (Padding_entriesInitialized)
+    return Unit_instance;
+  Padding_entriesInitialized = true;
+  Padding_NONE_instance = new Padding('NONE', 0);
+  Padding_ZERO_instance = new Padding('ZERO', 1);
+  Padding_SPACE_instance = new Padding('SPACE', 2);
+}
+function Padding(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function Padding_ZERO_getInstance() {
+  Padding_initEntries();
+  return Padding_ZERO_instance;
+}
+function Padding_SPACE_getInstance() {
+  Padding_initEntries();
+  return Padding_SPACE_instance;
+}
+function WithDate() {
+}
+function char(_this__u8e3s4, value) {
+  return _this__u8e3s4.ah(toString_0(value));
+}
+function AbstractDateTimeFormatBuilder() {
+}
+function get_ISO_DATE() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  // Inline function 'kotlin.getValue' call
+  var this_0 = ISO_DATE$delegate;
+  ISO_DATE$factory();
+  return this_0.b2();
+}
+var ISO_DATE$delegate;
+function get_ISO_DATE_BASIC() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  // Inline function 'kotlin.getValue' call
+  var this_0 = ISO_DATE_BASIC$delegate;
+  ISO_DATE_BASIC$factory();
+  return this_0.b2();
+}
+var ISO_DATE_BASIC$delegate;
+function get_emptyIncompleteLocalDate() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  return emptyIncompleteLocalDate;
+}
+var emptyIncompleteLocalDate;
+function IncompleteLocalDate(year, monthNumber, dayOfMonth, isoDayOfWeek) {
+  year = year === VOID ? null : year;
+  monthNumber = monthNumber === VOID ? null : monthNumber;
+  dayOfMonth = dayOfMonth === VOID ? null : dayOfMonth;
+  isoDayOfWeek = isoDayOfWeek === VOID ? null : isoDayOfWeek;
+  this.gh_1 = year;
+  this.hh_1 = monthNumber;
+  this.ih_1 = dayOfMonth;
+  this.jh_1 = isoDayOfWeek;
+}
+protoOf(IncompleteLocalDate).kh = function (_set____db54di) {
+  this.gh_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).lh = function () {
+  return this.gh_1;
+};
+protoOf(IncompleteLocalDate).mh = function (_set____db54di) {
+  this.hh_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).nh = function () {
+  return this.hh_1;
+};
+protoOf(IncompleteLocalDate).oh = function (_set____db54di) {
+  this.ih_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).ph = function () {
+  return this.ih_1;
+};
+protoOf(IncompleteLocalDate).qh = function (_set____db54di) {
+  this.jh_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).rh = function () {
+  return this.jh_1;
+};
+protoOf(IncompleteLocalDate).sh = function () {
+  var date = LocalDate_init_$Create$(requireParsedField(this.gh_1, 'year'), requireParsedField(this.hh_1, 'monthNumber'), requireParsedField(this.ih_1, 'dayOfMonth'));
+  var tmp0_safe_receiver = this.jh_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(tmp0_safe_receiver === get_isoDayNumber(date.uh()))) {
+      throw DateTimeFormatException_init_$Create$_0('Can not create a LocalDate from the given input: ' + ('the day of week is ' + DayOfWeek(tmp0_safe_receiver).toString() + ' but the date is ' + date.toString() + ', which is a ' + date.uh().toString()));
+    }
+  }
+  return date;
+};
+protoOf(IncompleteLocalDate).vh = function () {
+  return new IncompleteLocalDate(this.gh_1, this.hh_1, this.ih_1, this.jh_1);
+};
+protoOf(IncompleteLocalDate).equals = function (other) {
+  var tmp;
+  var tmp_0;
+  var tmp_1;
+  var tmp_2;
+  if (other instanceof IncompleteLocalDate) {
+    tmp_2 = this.gh_1 == other.gh_1;
+  } else {
+    tmp_2 = false;
+  }
+  if (tmp_2) {
+    tmp_1 = this.hh_1 == other.hh_1;
+  } else {
+    tmp_1 = false;
+  }
+  if (tmp_1) {
+    tmp_0 = this.ih_1 == other.ih_1;
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = this.jh_1 == other.jh_1;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(IncompleteLocalDate).hashCode = function () {
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver = this.gh_1;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+  var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+  var tmp = imul(tmp$ret$0, 31);
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver_0 = this.hh_1;
+  var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+  var tmp$ret$1 = tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0;
+  var tmp_0 = tmp + imul(tmp$ret$1, 31) | 0;
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver_1 = this.ih_1;
+  var tmp1_elvis_lhs_1 = tmp0_safe_receiver_1 == null ? null : hashCode(tmp0_safe_receiver_1);
+  var tmp$ret$2 = tmp1_elvis_lhs_1 == null ? 0 : tmp1_elvis_lhs_1;
+  var tmp_1 = tmp_0 + imul(tmp$ret$2, 31) | 0;
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver_2 = this.jh_1;
+  var tmp1_elvis_lhs_2 = tmp0_safe_receiver_2 == null ? null : hashCode(tmp0_safe_receiver_2);
+  var tmp$ret$3 = tmp1_elvis_lhs_2 == null ? 0 : tmp1_elvis_lhs_2;
+  return tmp_1 + imul(tmp$ret$3, 31) | 0;
+};
+protoOf(IncompleteLocalDate).toString = function () {
+  var tmp0_elvis_lhs = this.gh_1;
+  var tmp = toString(tmp0_elvis_lhs == null ? '??' : tmp0_elvis_lhs);
+  var tmp1_elvis_lhs = this.hh_1;
+  var tmp_0 = toString(tmp1_elvis_lhs == null ? '??' : tmp1_elvis_lhs);
+  var tmp2_elvis_lhs = this.ih_1;
+  var tmp_1 = toString(tmp2_elvis_lhs == null ? '??' : tmp2_elvis_lhs);
+  var tmp3_elvis_lhs = this.jh_1;
+  return tmp + '-' + tmp_0 + '-' + tmp_1 + ' (day of week is ' + toString(tmp3_elvis_lhs == null ? '??' : tmp3_elvis_lhs) + ')';
+};
+function Companion_1() {
+}
+protoOf(Companion_1).wh = function (block) {
+  var builder = new Builder(new AppendableFormatStructure());
+  block(builder);
+  return new LocalDateFormat(builder.eh());
+};
+var Companion_instance_1;
+function Companion_getInstance_1() {
+  return Companion_instance_1;
+}
+function Builder(actualBuilder) {
+  this.xh_1 = actualBuilder;
+}
+protoOf(Builder).bh = function () {
+  return this.xh_1;
+};
+protoOf(Builder).yh = function (structure) {
+  return this.xh_1.dh(structure);
+};
+function LocalDateFormat(actualFormat) {
+  AbstractDateTimeFormat.call(this);
+  this.zh_1 = actualFormat;
+}
+protoOf(LocalDateFormat).mg = function () {
+  return this.zh_1;
+};
+protoOf(LocalDateFormat).ai = function (intermediate) {
+  return intermediate.sh();
+};
+protoOf(LocalDateFormat).ng = function (intermediate) {
+  return this.ai(intermediate instanceof IncompleteLocalDate ? intermediate : THROW_CCE());
+};
+protoOf(LocalDateFormat).og = function () {
+  return get_emptyIncompleteLocalDate();
+};
+function requireParsedField(field, name) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  if (field == null) {
+    throw DateTimeFormatException_init_$Create$_0('Can not create a ' + name + ' from the given input: the field ' + name + ' is missing');
+  }
+  return field;
+}
+function AbstractWithDateBuilder() {
+}
+function YearDirective(padding, isYearOfEra) {
+  isYearOfEra = isYearOfEra === VOID ? false : isYearOfEra;
+  var tmp = DateFields_getInstance().bi_1;
+  // Inline function 'kotlinx.datetime.format.minDigits' call
+  var tmp_0 = padding.equals(Padding_ZERO_getInstance()) ? 4 : 1;
+  // Inline function 'kotlinx.datetime.format.spaces' call
+  var tmp$ret$1 = padding.equals(Padding_SPACE_getInstance()) ? 4 : null;
+  SignedIntFieldFormatDirective.call(this, tmp, tmp_0, null, tmp$ret$1, 4);
+  this.ki_1 = padding;
+  this.li_1 = isYearOfEra;
+}
+protoOf(YearDirective).equals = function (other) {
+  var tmp;
+  var tmp_0;
+  if (other instanceof YearDirective) {
+    tmp_0 = this.ki_1.equals(other.ki_1);
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = this.li_1 === other.li_1;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(YearDirective).hashCode = function () {
+  return imul(this.ki_1.hashCode(), 31) + getBooleanHashCode(this.li_1) | 0;
+};
+function MonthDirective(padding) {
+  var tmp = DateFields_getInstance().ci_1;
+  // Inline function 'kotlinx.datetime.format.minDigits' call
+  var tmp_0 = padding.equals(Padding_ZERO_getInstance()) ? 2 : 1;
+  // Inline function 'kotlinx.datetime.format.spaces' call
+  var tmp$ret$1 = padding.equals(Padding_SPACE_getInstance()) ? 2 : null;
+  UnsignedIntFieldFormatDirective.call(this, tmp, tmp_0, tmp$ret$1);
+  this.wi_1 = padding;
+}
+protoOf(MonthDirective).equals = function (other) {
+  var tmp;
+  if (other instanceof MonthDirective) {
+    tmp = this.wi_1.equals(other.wi_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(MonthDirective).hashCode = function () {
+  return this.wi_1.hashCode();
+};
+function DayDirective(padding) {
+  var tmp = DateFields_getInstance().di_1;
+  // Inline function 'kotlinx.datetime.format.minDigits' call
+  var tmp_0 = padding.equals(Padding_ZERO_getInstance()) ? 2 : 1;
+  // Inline function 'kotlinx.datetime.format.spaces' call
+  var tmp$ret$1 = padding.equals(Padding_SPACE_getInstance()) ? 2 : null;
+  UnsignedIntFieldFormatDirective.call(this, tmp, tmp_0, tmp$ret$1);
+  this.fj_1 = padding;
+}
+protoOf(DayDirective).equals = function (other) {
+  var tmp;
+  if (other instanceof DayDirective) {
+    tmp = this.fj_1.equals(other.fj_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(DayDirective).hashCode = function () {
+  return this.fj_1.hashCode();
+};
+function DateFields() {
+  DateFields_instance = this;
+  this.bi_1 = new GenericFieldSpec(new PropertyAccessor(year$factory()));
+  this.ci_1 = new UnsignedFieldSpec(new PropertyAccessor(monthNumber$factory()), 1, 12);
+  this.di_1 = new UnsignedFieldSpec(new PropertyAccessor(dayOfMonth$factory()), 1, 31);
+  this.ei_1 = new UnsignedFieldSpec(new PropertyAccessor(isoDayOfWeek$factory()), 1, 7);
+}
+var DateFields_instance;
+function DateFields_getInstance() {
+  if (DateFields_instance == null)
+    new DateFields();
+  return DateFields_instance;
+}
+function ISO_DATE$delegate$lambda() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp = Companion_instance_1;
+  return tmp.wh(ISO_DATE$delegate$lambda$lambda);
+}
+function ISO_DATE$delegate$lambda$lambda($this$build) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  $this$build.vg();
+  char($this$build, _Char___init__impl__6a9atx(45));
+  $this$build.xg();
+  char($this$build, _Char___init__impl__6a9atx(45));
+  $this$build.zg();
+  return Unit_instance;
+}
+function ISO_DATE_BASIC$delegate$lambda() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp = Companion_instance_1;
+  return tmp.wh(ISO_DATE_BASIC$delegate$lambda$lambda);
+}
+function ISO_DATE_BASIC$delegate$lambda$lambda($this$build) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  $this$build.vg();
+  $this$build.xg();
+  $this$build.zg();
+  return Unit_instance;
+}
+function ISO_DATE$factory() {
+  return getPropertyCallableRef('ISO_DATE', 0, KProperty0, function () {
+    return get_ISO_DATE();
+  }, null);
+}
+function ISO_DATE_BASIC$factory() {
+  return getPropertyCallableRef('ISO_DATE_BASIC', 0, KProperty0, function () {
+    return get_ISO_DATE_BASIC();
+  }, null);
+}
+function year$factory() {
+  return getPropertyCallableRef('year', 1, KMutableProperty1, function (receiver) {
+    return receiver.lh();
+  }, function (receiver, value) {
+    return receiver.kh(value);
+  });
+}
+function monthNumber$factory() {
+  return getPropertyCallableRef('monthNumber', 1, KMutableProperty1, function (receiver) {
+    return receiver.nh();
+  }, function (receiver, value) {
+    return receiver.mh(value);
+  });
+}
+function dayOfMonth$factory() {
+  return getPropertyCallableRef('dayOfMonth', 1, KMutableProperty1, function (receiver) {
+    return receiver.ph();
+  }, function (receiver, value) {
+    return receiver.oh(value);
+  });
+}
+function isoDayOfWeek$factory() {
+  return getPropertyCallableRef('isoDayOfWeek', 1, KMutableProperty1, function (receiver) {
+    return receiver.rh();
+  }, function (receiver, value) {
+    return receiver.qh(value);
+  });
+}
+var properties_initialized_LocalDateFormat_kt_fmnlhc;
+function _init_properties_LocalDateFormat_kt__k1uk9u() {
+  if (!properties_initialized_LocalDateFormat_kt_fmnlhc) {
+    properties_initialized_LocalDateFormat_kt_fmnlhc = true;
+    ISO_DATE$delegate = lazy(ISO_DATE$delegate$lambda);
+    ISO_DATE_BASIC$delegate = lazy(ISO_DATE_BASIC$delegate$lambda);
+    emptyIncompleteLocalDate = new IncompleteLocalDate();
+  }
+}
+function AppendableFormatStructure() {
+  var tmp = this;
+  // Inline function 'kotlin.collections.mutableListOf' call
+  tmp.ch_1 = ArrayList_init_$Create$();
+}
+protoOf(AppendableFormatStructure).eh = function () {
+  return new ConcatenatedFormatStructure(this.ch_1);
+};
+protoOf(AppendableFormatStructure).dh = function (format) {
+  if (isInterface(format, NonConcatenatedFormatStructure)) {
+    this.ch_1.e(format);
+  } else {
+    if (format instanceof ConcatenatedFormatStructure) {
+      // Inline function 'kotlin.collections.forEach' call
+      var tmp0_iterator = format.fh_1.j();
+      while (tmp0_iterator.k()) {
+        var element = tmp0_iterator.l();
+        // Inline function 'kotlinx.datetime.internal.format.AppendableFormatStructure.add.<anonymous>' call
+        this.ch_1.e(element);
+      }
+    }
+  }
+};
+function Accessor$getterNotNull$ref($boundThis) {
+  var l = function (p0) {
+    return $boundThis.gj(p0);
+  };
+  l.callableName = 'getterNotNull';
+  return l;
+}
+function SignedIntFieldFormatDirective(field, minDigits, maxDigits, spacePadding, outputPlusOnExceededWidth) {
+  this.mi_1 = field;
+  this.ni_1 = minDigits;
+  this.oi_1 = maxDigits;
+  this.pi_1 = spacePadding;
+  this.qi_1 = outputPlusOnExceededWidth;
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.ni_1 == null || this.ni_1 >= 0)) {
+    // Inline function 'kotlinx.datetime.internal.format.SignedIntFieldFormatDirective.<anonymous>' call
+    var message = 'The minimum number of digits (' + this.ni_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.oi_1 == null || this.ni_1 == null || this.oi_1 >= this.ni_1)) {
+    // Inline function 'kotlinx.datetime.internal.format.SignedIntFieldFormatDirective.<anonymous>' call
+    var message_0 = 'The maximum number of digits (' + this.oi_1 + ') is less than the minimum number of digits (' + this.ni_1 + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+protoOf(SignedIntFieldFormatDirective).ri = function () {
+  var tmp = Accessor$getterNotNull$ref(this.mi_1.hj());
+  var tmp0_elvis_lhs = this.ni_1;
+  var formatter = new SignedIntFormatterStructure(tmp, tmp0_elvis_lhs == null ? 0 : tmp0_elvis_lhs, this.qi_1);
+  return !(this.pi_1 == null) ? new SpacePaddedFormatter(formatter, this.pi_1) : formatter;
+};
+protoOf(SignedIntFieldFormatDirective).tg = function () {
+  return SignedIntParser(this.ni_1, this.oi_1, this.pi_1, this.mi_1.hj(), this.mi_1.i2(), this.qi_1);
+};
+function Accessor$getterNotNull$ref_0($boundThis) {
+  var l = function (p0) {
+    return $boundThis.gj(p0);
+  };
+  l.callableName = 'getterNotNull';
+  return l;
+}
+function UnsignedIntFieldFormatDirective(field, minDigits, spacePadding) {
+  this.xi_1 = field;
+  this.yi_1 = minDigits;
+  this.zi_1 = spacePadding;
+  this.aj_1 = this.xi_1.oj_1;
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.yi_1 >= 0)) {
+    // Inline function 'kotlinx.datetime.internal.format.UnsignedIntFieldFormatDirective.<anonymous>' call
+    var message = 'The minimum number of digits (' + this.yi_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.aj_1 >= this.yi_1)) {
+    // Inline function 'kotlinx.datetime.internal.format.UnsignedIntFieldFormatDirective.<anonymous>' call
+    var message_0 = 'The maximum number of digits (' + this.aj_1 + ') is less than the minimum number of digits (' + this.yi_1 + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  if (!(this.zi_1 == null)) {
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.zi_1 > this.yi_1)) {
+      // Inline function 'kotlinx.datetime.internal.format.UnsignedIntFieldFormatDirective.<anonymous>' call
+      var message_1 = 'The space padding (' + this.zi_1 + ') should be more than the minimum number of digits (' + this.yi_1 + ')';
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+  }
+}
+protoOf(UnsignedIntFieldFormatDirective).ri = function () {
+  var formatter = new UnsignedIntFormatterStructure(Accessor$getterNotNull$ref_0(this.xi_1.ij_1), this.yi_1);
+  return !(this.zi_1 == null) ? new SpacePaddedFormatter(formatter, this.zi_1) : formatter;
+};
+protoOf(UnsignedIntFieldFormatDirective).tg = function () {
+  return spaceAndZeroPaddedUnsignedInt(this.yi_1, this.aj_1, this.zi_1, this.xi_1.ij_1, this.xi_1.lj_1);
+};
+function GenericFieldSpec(accessor, name, defaultValue, sign) {
+  name = name === VOID ? accessor.i2() : name;
+  defaultValue = defaultValue === VOID ? null : defaultValue;
+  sign = sign === VOID ? null : sign;
+  AbstractFieldSpec.call(this);
+  this.pj_1 = accessor;
+  this.qj_1 = name;
+  this.rj_1 = defaultValue;
+  this.sj_1 = sign;
+}
+protoOf(GenericFieldSpec).hj = function () {
+  return this.pj_1;
+};
+protoOf(GenericFieldSpec).i2 = function () {
+  return this.qj_1;
+};
+protoOf(GenericFieldSpec).tj = function () {
+  return this.rj_1;
+};
+function PropertyAccessor(property) {
+  this.uj_1 = property;
+}
+protoOf(PropertyAccessor).i2 = function () {
+  return this.uj_1.callableName;
+};
+protoOf(PropertyAccessor).vj = function (container, newValue) {
+  var oldValue = this.uj_1.get(container);
+  var tmp;
+  if (oldValue === null) {
+    this.uj_1.set(container, newValue);
+    tmp = null;
+  } else if (equals(oldValue, newValue)) {
+    tmp = null;
+  } else {
+    tmp = oldValue;
+  }
+  return tmp;
+};
+protoOf(PropertyAccessor).wj = function (container, newValue) {
+  var tmp = (container == null ? true : !(container == null)) ? container : THROW_CCE();
+  return this.vj(tmp, (newValue == null ? true : !(newValue == null)) ? newValue : THROW_CCE());
+};
+protoOf(PropertyAccessor).xj = function (container) {
+  return this.uj_1.get(container);
+};
+function UnsignedFieldSpec(accessor, minValue, maxValue, name, defaultValue, sign) {
+  name = name === VOID ? accessor.i2() : name;
+  defaultValue = defaultValue === VOID ? null : defaultValue;
+  sign = sign === VOID ? null : sign;
+  AbstractFieldSpec.call(this);
+  this.ij_1 = accessor;
+  this.jj_1 = minValue;
+  this.kj_1 = maxValue;
+  this.lj_1 = name;
+  this.mj_1 = defaultValue;
+  this.nj_1 = sign;
+  var tmp = this;
+  var tmp_0;
+  if (this.kj_1 < 10) {
+    tmp_0 = 1;
+  } else if (this.kj_1 < 100) {
+    tmp_0 = 2;
+  } else if (this.kj_1 < 1000) {
+    tmp_0 = 3;
+  } else {
+    throw IllegalArgumentException_init_$Create$('Max value ' + this.kj_1 + ' is too large');
+  }
+  tmp.oj_1 = tmp_0;
+}
+protoOf(UnsignedFieldSpec).hj = function () {
+  return this.ij_1;
+};
+protoOf(UnsignedFieldSpec).i2 = function () {
+  return this.lj_1;
+};
+protoOf(UnsignedFieldSpec).tj = function () {
+  return this.mj_1;
+};
+function Accessor() {
+}
+function AbstractFieldSpec() {
+}
+protoOf(AbstractFieldSpec).toString = function () {
+  return 'The field ' + this.i2() + ' (default value is ' + toString_1(this.tj()) + ')';
+};
+function CachedFormatStructure(formats) {
+  ConcatenatedFormatStructure.call(this, formats);
+  this.rg_1 = protoOf(ConcatenatedFormatStructure).ri.call(this);
+  this.sg_1 = protoOf(ConcatenatedFormatStructure).tg.call(this);
+}
+protoOf(CachedFormatStructure).ri = function () {
+  return this.rg_1;
+};
+protoOf(CachedFormatStructure).tg = function () {
+  return this.sg_1;
+};
+function BasicFormatStructure(directive) {
+  this.yj_1 = directive;
+}
+protoOf(BasicFormatStructure).toString = function () {
+  return 'BasicFormatStructure(' + toString(this.yj_1) + ')';
+};
+protoOf(BasicFormatStructure).equals = function (other) {
+  var tmp;
+  if (other instanceof BasicFormatStructure) {
+    tmp = equals(this.yj_1, other.yj_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(BasicFormatStructure).hashCode = function () {
+  return hashCode(this.yj_1);
+};
+protoOf(BasicFormatStructure).tg = function () {
+  return this.yj_1.tg();
+};
+protoOf(BasicFormatStructure).ri = function () {
+  return this.yj_1.ri();
+};
+function ConstantFormatStructure(string) {
+  this.zj_1 = string;
+}
+protoOf(ConstantFormatStructure).toString = function () {
+  return 'ConstantFormatStructure(' + this.zj_1 + ')';
+};
+protoOf(ConstantFormatStructure).equals = function (other) {
+  var tmp;
+  if (other instanceof ConstantFormatStructure) {
+    tmp = this.zj_1 === other.zj_1;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(ConstantFormatStructure).hashCode = function () {
+  return getStringHashCode(this.zj_1);
+};
+protoOf(ConstantFormatStructure).tg = function () {
+  var tmp;
+  // Inline function 'kotlin.text.isEmpty' call
+  var this_0 = this.zj_1;
+  if (charSequenceLength(this_0) === 0) {
+    tmp = emptyList();
+  } else {
+    // Inline function 'kotlin.collections.buildList' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.collections.buildListInternal' call
+    // Inline function 'kotlin.apply' call
+    var this_1 = ArrayList_init_$Create$();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>' call
+    var tmp_0;
+    if (isAsciiDigit(charSequenceGet(this.zj_1, 0))) {
+      var tmp$ret$4;
+      $l$block: {
+        // Inline function 'kotlin.text.takeWhile' call
+        var this_2 = this.zj_1;
+        var inductionVariable = 0;
+        var last = this_2.length;
+        if (inductionVariable < last)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+            var it = charSequenceGet(this_2, index);
+            if (!isAsciiDigit(it)) {
+              // Inline function 'kotlin.text.substring' call
+              // Inline function 'kotlin.js.asDynamic' call
+              tmp$ret$4 = this_2.substring(0, index);
+              break $l$block;
+            }
+          }
+           while (inductionVariable < last);
+        tmp$ret$4 = this_2;
+      }
+      this_1.e(new NumberSpanParserOperation(listOf(new ConstantNumberConsumer(tmp$ret$4))));
+      var tmp$ret$8;
+      $l$block_0: {
+        // Inline function 'kotlin.text.dropWhile' call
+        var this_3 = this.zj_1;
+        var inductionVariable_0 = 0;
+        var last_0 = charSequenceLength(this_3) - 1 | 0;
+        if (inductionVariable_0 <= last_0)
+          do {
+            var index_0 = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+            var it_0 = charSequenceGet(this_3, index_0);
+            if (!isAsciiDigit(it_0)) {
+              // Inline function 'kotlin.text.substring' call
+              // Inline function 'kotlin.js.asDynamic' call
+              tmp$ret$8 = this_3.substring(index_0);
+              break $l$block_0;
+            }
+          }
+           while (inductionVariable_0 <= last_0);
+        tmp$ret$8 = '';
+      }
+      tmp_0 = tmp$ret$8;
+    } else {
+      tmp_0 = this.zj_1;
+    }
+    var suffix = tmp_0;
+    // Inline function 'kotlin.text.isNotEmpty' call
+    if (charSequenceLength(suffix) > 0) {
+      if (isAsciiDigit(charSequenceGet(suffix, suffix.length - 1 | 0))) {
+        var tmp$ret$13;
+        $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;
+              // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+              var it_1 = charSequenceGet(suffix, index_1);
+              if (!isAsciiDigit(it_1)) {
+                // Inline function 'kotlin.text.substring' call
+                var endIndex = index_1 + 1 | 0;
+                // Inline function 'kotlin.js.asDynamic' call
+                tmp$ret$13 = suffix.substring(0, endIndex);
+                break $l$block_1;
+              }
+            }
+             while (0 <= inductionVariable_1);
+          tmp$ret$13 = '';
+        }
+        this_1.e(new PlainStringParserOperation(tmp$ret$13));
+        var tmp$ret$17;
+        $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;
+              // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+              var it_2 = charSequenceGet(suffix, index_2);
+              if (!isAsciiDigit(it_2)) {
+                // Inline function 'kotlin.text.substring' call
+                var startIndex = index_2 + 1 | 0;
+                // Inline function 'kotlin.js.asDynamic' call
+                tmp$ret$17 = suffix.substring(startIndex);
+                break $l$block_2;
+              }
+            }
+             while (0 <= inductionVariable_2);
+          tmp$ret$17 = suffix;
+        }
+        this_1.e(new NumberSpanParserOperation(listOf(new ConstantNumberConsumer(tmp$ret$17))));
+      } else {
+        this_1.e(new PlainStringParserOperation(suffix));
+      }
+    }
+    tmp = this_1.d5();
+  }
+  return new ParserStructure(tmp, emptyList());
+};
+protoOf(ConstantFormatStructure).ri = function () {
+  return new ConstantStringFormatterStructure(this.zj_1);
+};
+function ConcatenatedFormatStructure(formats) {
+  this.fh_1 = formats;
+}
+protoOf(ConcatenatedFormatStructure).toString = function () {
+  return 'ConcatenatedFormatStructure(' + joinToString(this.fh_1, ', ') + ')';
+};
+protoOf(ConcatenatedFormatStructure).equals = function (other) {
+  var tmp;
+  if (other instanceof ConcatenatedFormatStructure) {
+    tmp = equals(this.fh_1, other.fh_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(ConcatenatedFormatStructure).hashCode = function () {
+  return hashCode(this.fh_1);
+};
+protoOf(ConcatenatedFormatStructure).tg = function () {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = this.fh_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+  var tmp0_iterator = this_0.j();
+  while (tmp0_iterator.k()) {
+    var item = tmp0_iterator.l();
+    // Inline function 'kotlinx.datetime.internal.format.ConcatenatedFormatStructure.parser.<anonymous>' call
+    var tmp$ret$0 = item.tg();
+    destination.e(tmp$ret$0);
+  }
+  return concat(destination);
+};
+protoOf(ConcatenatedFormatStructure).ri = function () {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = this.fh_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+  var tmp0_iterator = this_0.j();
+  while (tmp0_iterator.k()) {
+    var item = tmp0_iterator.l();
+    // Inline function 'kotlinx.datetime.internal.format.ConcatenatedFormatStructure.formatter.<anonymous>' call
+    var tmp$ret$0 = item.ri();
+    destination.e(tmp$ret$0);
+  }
+  var formatters = destination;
+  var tmp;
+  if (formatters.o() === 1) {
+    tmp = single(formatters);
+  } else {
+    tmp = new ConcatenatedFormatter(formatters);
+  }
+  return tmp;
+};
+function NonConcatenatedFormatStructure() {
+}
+function SpacePaddedFormatter(formatter, padding) {
+  this.ak_1 = formatter;
+  this.bk_1 = padding;
+}
+function ConcatenatedFormatter(formatters) {
+  this.ck_1 = formatters;
+}
+function SignedIntFormatterStructure(number, zeroPadding, outputPlusOnExceededWidth) {
+  this.dk_1 = number;
+  this.ek_1 = zeroPadding;
+  this.fk_1 = outputPlusOnExceededWidth;
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.ek_1 >= 0)) {
+    // Inline function 'kotlinx.datetime.internal.format.formatter.SignedIntFormatterStructure.<anonymous>' call
+    var message = 'The minimum number of digits (' + this.ek_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.ek_1 <= 9)) {
+    // Inline function 'kotlinx.datetime.internal.format.formatter.SignedIntFormatterStructure.<anonymous>' call
+    var message_0 = 'The minimum number of digits (' + this.ek_1 + ') exceeds the length of an Int';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+function UnsignedIntFormatterStructure(number, zeroPadding) {
+  this.gk_1 = number;
+  this.hk_1 = zeroPadding;
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.hk_1 >= 0)) {
+    // Inline function 'kotlinx.datetime.internal.format.formatter.UnsignedIntFormatterStructure.<anonymous>' call
+    var message = 'The minimum number of digits (' + this.hk_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.hk_1 <= 9)) {
+    // Inline function 'kotlinx.datetime.internal.format.formatter.UnsignedIntFormatterStructure.<anonymous>' call
+    var message_0 = 'The minimum number of digits (' + this.hk_1 + ') exceeds the length of an Int';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+function ConstantStringFormatterStructure(string) {
+  this.ik_1 = string;
+}
+function ConstantNumberConsumer(expected) {
+  NumberConsumer.call(this, expected.length, 'the predefined string ' + expected);
+  this.lk_1 = expected;
+}
+protoOf(ConstantNumberConsumer).mk = function (storage, input, start, end) {
+  var tmp;
+  // Inline function 'kotlin.text.substring' call
+  if (toString(charSequenceSubSequence(input, start, end)) === this.lk_1) {
+    tmp = null;
+  } else {
+    tmp = new WrongConstant(this.lk_1);
+  }
+  return tmp;
+};
+function NumberConsumer(length, whatThisExpects) {
+  this.nk_1 = length;
+  this.ok_1 = whatThisExpects;
+}
+protoOf(NumberConsumer).a = function () {
+  return this.nk_1;
+};
+function ExpectedInt() {
+}
+protoOf(ExpectedInt).pk = function () {
+  return 'expected an Int value';
+};
+var ExpectedInt_instance;
+function ExpectedInt_getInstance() {
+  return ExpectedInt_instance;
+}
+function TooManyDigits(maxDigits) {
+  this.qk_1 = maxDigits;
+}
+protoOf(TooManyDigits).pk = function () {
+  return 'expected at most ' + this.qk_1 + ' digits';
+};
+function TooFewDigits(minDigits) {
+  this.rk_1 = minDigits;
+}
+protoOf(TooFewDigits).pk = function () {
+  return 'expected at least ' + this.rk_1 + ' digits';
+};
+function WrongConstant(expected) {
+  this.sk_1 = expected;
+}
+protoOf(WrongConstant).pk = function () {
+  return "expected '" + this.sk_1 + "'";
+};
+function Conflicting(conflicting) {
+  this.tk_1 = conflicting;
+}
+protoOf(Conflicting).pk = function () {
+  return "attempted to overwrite the existing value '" + toString(this.tk_1) + "'";
+};
+function setWithoutReassigning(_this__u8e3s4, receiver, value) {
+  var tmp0_elvis_lhs = _this__u8e3s4.wj(receiver, value);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var conflictingValue = tmp;
+  return new Conflicting(conflictingValue);
+}
+function UnsignedIntConsumer(minLength, maxLength, setter, name, multiplyByMinus1) {
+  multiplyByMinus1 = multiplyByMinus1 === VOID ? false : multiplyByMinus1;
+  NumberConsumer.call(this, minLength == maxLength ? minLength : null, name);
+  this.wk_1 = minLength;
+  this.xk_1 = maxLength;
+  this.yk_1 = setter;
+  this.zk_1 = multiplyByMinus1;
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(this.a() == null || numberRangeToNumber(1, 9).ge(this.a()))) {
+    // Inline function 'kotlinx.datetime.internal.format.parser.UnsignedIntConsumer.<anonymous>' call
+    var message = 'Invalid length for field ' + this.ok_1 + ': ' + this.a();
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+}
+protoOf(UnsignedIntConsumer).mk = function (storage, input, start, end) {
+  var tmp;
+  if (!(this.xk_1 == null) && (end - start | 0) > this.xk_1) {
+    tmp = new TooManyDigits(this.xk_1);
+  } else if (!(this.wk_1 == null) && (end - start | 0) < this.wk_1) {
+    tmp = new TooFewDigits(this.wk_1);
+  } else {
+    var result = parseAsciiIntOrNull(input, start, end);
+    tmp = result == null ? ExpectedInt_instance : setWithoutReassigning(this.yk_1, storage, this.zk_1 ? -result | 0 : result);
+  }
+  return tmp;
+};
+function parseAsciiIntOrNull(_this__u8e3s4, start, end) {
+  var result = 0;
+  var inductionVariable = start;
+  if (inductionVariable < end)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var digit = charSequenceGet(_this__u8e3s4, i);
+      result = imul(result, 10) + asciiDigitToInt(digit) | 0;
+      if (result < 0)
+        return null;
+    }
+     while (inductionVariable < end);
+  return result;
+}
+function ParseError(position, message) {
+  this.al_1 = position;
+  this.bl_1 = message;
+}
+function _ParseResult___init__impl__gvz3cn(value) {
+  return value;
+}
+function _ParseResult___get_value__impl__86mnxf($this) {
+  return $this;
+}
+function Companion_2() {
+}
+protoOf(Companion_2).cl = function (indexOfNextUnparsed) {
+  return _ParseResult___init__impl__gvz3cn(indexOfNextUnparsed);
+};
+protoOf(Companion_2).dl = function (position, message) {
+  return _ParseResult___init__impl__gvz3cn(new ParseError(position, message));
+};
+var Companion_instance_2;
+function Companion_getInstance_2() {
+  return Companion_instance_2;
+}
+function _Parser___init__impl__gdyfby(commands) {
+  return commands;
+}
+function _get_commands__a20n1($this) {
+  return $this;
+}
+function Parser__match_impl_nzt83d($this, input, initialContainer, startIndex) {
+  // Inline function 'kotlin.collections.mutableListOf' call
+  var errors = ArrayList_init_$Create$();
+  // Inline function 'kotlinx.datetime.internal.format.parser.Parser.parse' call
+  var parseOptions = mutableListOf([new ParserState(initialContainer, _get_commands__a20n1($this), startIndex)]);
+  iterate_over_alternatives: while (true) {
+    var tmp0_elvis_lhs = removeLastOrNull(parseOptions);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      break iterate_over_alternatives;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var state = tmp;
+    var output = state.el_1.vh();
+    var inputPosition = state.gl_1;
+    var parserStructure = state.fl_1;
+    // Inline function 'kotlin.run' call
+    var this_0 = new Parser($this);
+    // Inline function 'kotlin.contracts.contract' call
+    $l$block: {
+      // Inline function 'kotlinx.datetime.internal.format.parser.Parser.parse.<anonymous>' call
+      this_0.hl_1;
+      var inductionVariable = 0;
+      var last = parserStructure.il_1.o() - 1 | 0;
+      if (inductionVariable <= last)
+        do {
+          var ix = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          // Inline function 'kotlinx.datetime.internal.format.parser.ParseResult.match' call
+          var this_1 = parserStructure.il_1.n(ix).kl(output, input, inputPosition);
+          var tmp0_subject = _ParseResult___get_value__impl__86mnxf(this_1);
+          var tmp_0;
+          if (typeof tmp0_subject === 'number') {
+            inputPosition = _ParseResult___get_value__impl__86mnxf(this_1);
+            tmp_0 = Unit_instance;
+          } else {
+            if (tmp0_subject instanceof ParseError) {
+              // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+              var it = _ParseResult___get_value__impl__86mnxf(this_1);
+              errors.e(it);
+              break $l$block;
+            } else {
+              var message = 'Unexpected parse result: ' + toString(_ParseResult___get_value__impl__86mnxf(this_1));
+              throw IllegalStateException_init_$Create$(toString(message));
+            }
+          }
+        }
+         while (inductionVariable <= last);
+      if (parserStructure.jl_1.m()) {
+        if (false || inputPosition === charSequenceLength(input)) {
+          // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+          return output;
+        } else {
+          // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+          var tmp_1 = inputPosition;
+          var it_0 = new ParseError(tmp_1, Parser$match$lambda);
+          errors.e(it_0);
+        }
+      } else {
+        var inductionVariable_0 = parserStructure.jl_1.o() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var ix_0 = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            parseOptions.e(new ParserState(output, parserStructure.jl_1.n(ix_0), inputPosition));
+          }
+           while (0 <= inductionVariable_0);
+      }
+    }
+  }
+  // Inline function 'kotlin.collections.sortByDescending' call
+  if (errors.o() > 1) {
+    // Inline function 'kotlin.comparisons.compareByDescending' call
+    var tmp_2 = Parser$match$lambda_0;
+    var tmp$ret$4 = new sam$kotlin_Comparator$0(tmp_2);
+    sortWith(errors, tmp$ret$4);
+  }
+  throw new ParseException(errors);
+}
+function Parser__match$default_impl_x2xlti($this, input, initialContainer, startIndex, $super) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  var tmp;
+  if ($super === VOID) {
+    tmp = Parser__match_impl_nzt83d($this, input, initialContainer, startIndex);
+  } else {
+    var tmp_0 = $super;
+    tmp = (tmp_0 == null ? null : new Parser(tmp_0)).ll.call(new Parser($this), input, initialContainer, startIndex);
+  }
+  return tmp;
+}
+function ParserState(output, parserStructure, inputPosition) {
+  this.el_1 = output;
+  this.fl_1 = parserStructure;
+  this.gl_1 = inputPosition;
+}
+function Parser__toString_impl_x33iea($this) {
+  return 'Parser(commands=' + $this.toString() + ')';
+}
+function Parser__hashCode_impl_bbxllf($this) {
+  return hashCode($this);
+}
+function Parser__equals_impl_djxokv($this, other) {
+  if (!(other instanceof Parser))
+    return false;
+  var tmp0_other_with_cast = other instanceof Parser ? other.hl_1 : THROW_CCE();
+  if (!equals($this, tmp0_other_with_cast))
+    return false;
+  return true;
+}
+function sam$kotlin_Comparator$0(function_0) {
+  this.ml_1 = function_0;
+}
+protoOf(sam$kotlin_Comparator$0).mb = function (a, b) {
+  return this.ml_1(a, b);
+};
+protoOf(sam$kotlin_Comparator$0).compare = function (a, b) {
+  return this.mb(a, b);
+};
+protoOf(sam$kotlin_Comparator$0).e3 = function () {
+  return this.ml_1;
+};
+protoOf(sam$kotlin_Comparator$0).equals = function (other) {
+  var tmp;
+  if (!(other == null) ? isInterface(other, Comparator) : false) {
+    var tmp_0;
+    if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+      tmp_0 = equals(this.e3(), other.e3());
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(sam$kotlin_Comparator$0).hashCode = function () {
+  return hashCode(this.e3());
+};
+function Parser$match$lambda() {
+  return 'There is more input to consume';
+}
+function Parser$match$lambda_0(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+  var tmp = b.al_1;
+  // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+  var tmp$ret$1 = a.al_1;
+  return compareValues(tmp, tmp$ret$1);
+}
+function Parser(commands) {
+  this.hl_1 = commands;
+}
+protoOf(Parser).toString = function () {
+  return Parser__toString_impl_x33iea(this.hl_1);
+};
+protoOf(Parser).hashCode = function () {
+  return Parser__hashCode_impl_bbxllf(this.hl_1);
+};
+protoOf(Parser).equals = function (other) {
+  return Parser__equals_impl_djxokv(this.hl_1, other);
+};
+function ParserStructure(operations, followedBy) {
+  this.il_1 = operations;
+  this.jl_1 = followedBy;
+}
+protoOf(ParserStructure).toString = function () {
+  return joinToString(this.il_1, ', ') + '(' + joinToString(this.jl_1, ';') + ')';
+};
+function ParseException(errors) {
+  Exception_init_$Init$(formatError(errors), this);
+  captureStack(this, ParseException);
+}
+function concat(_this__u8e3s4) {
+  // Inline function 'kotlin.collections.foldRight' call
+  var accumulator = new ParserStructure(emptyList(), emptyList());
+  if (!_this__u8e3s4.m()) {
+    var iterator = _this__u8e3s4.q(_this__u8e3s4.o());
+    while (iterator.j4()) {
+      // Inline function 'kotlinx.datetime.internal.format.parser.concat.<anonymous>' call
+      var parser = iterator.l4();
+      var acc = accumulator;
+      accumulator = concat$append(parser, acc);
+    }
+  }
+  var naiveParser = accumulator;
+  return concat$simplify(naiveParser, emptyList());
+}
+function formatError(errors) {
+  if (errors.o() === 1) {
+    return 'Position ' + errors.n(0).al_1 + ': ' + errors.n(0).bl_1();
+  }
+  var averageMessageLength = 33;
+  var tmp0_buffer = StringBuilder_init_$Create$_0(imul(averageMessageLength, errors.o()));
+  return joinTo(errors, tmp0_buffer, ', ', 'Errors: ', VOID, VOID, VOID, formatError$lambda).toString();
+}
+function concat$append(_this__u8e3s4, other) {
+  var tmp;
+  if (_this__u8e3s4.jl_1.m()) {
+    tmp = new ParserStructure(plus(_this__u8e3s4.il_1, other.il_1), other.jl_1);
+  } else {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = _this__u8e3s4.jl_1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.j();
+    while (tmp0_iterator.k()) {
+      var item = tmp0_iterator.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.concat.append.<anonymous>' call
+      var tmp$ret$0 = concat$append(item, other);
+      destination.e(tmp$ret$0);
+    }
+    tmp = new ParserStructure(_this__u8e3s4.il_1, destination);
+  }
+  return tmp;
+}
+function concat$simplify(_this__u8e3s4, unconditionalModifications) {
+  // Inline function 'kotlin.collections.mutableListOf' call
+  var newOperations = ArrayList_init_$Create$();
+  var currentNumberSpan = null;
+  var unconditionalModificationsForTails = toMutableList(unconditionalModifications);
+  var tmp0_iterator = _this__u8e3s4.il_1.j();
+  while (tmp0_iterator.k()) {
+    var op = tmp0_iterator.l();
+    if (op instanceof NumberSpanParserOperation) {
+      if (!(currentNumberSpan == null)) {
+        currentNumberSpan.p(op.nl_1);
+      } else {
+        currentNumberSpan = toMutableList(op.nl_1);
+      }
+    } else {
+      if (op instanceof UnconditionalModification) {
+        unconditionalModificationsForTails.e(op);
+      } else {
+        if (!(currentNumberSpan == null)) {
+          newOperations.e(new NumberSpanParserOperation(currentNumberSpan));
+          currentNumberSpan = null;
+        }
+        newOperations.e(op);
+      }
+    }
+  }
+  // Inline function 'kotlin.collections.ifEmpty' call
+  // Inline function 'kotlin.collections.flatMap' call
+  // Inline function 'kotlin.collections.flatMapTo' call
+  var this_0 = _this__u8e3s4.jl_1;
+  var destination = ArrayList_init_$Create$();
+  var tmp0_iterator_0 = this_0.j();
+  while (tmp0_iterator_0.k()) {
+    var element = tmp0_iterator_0.l();
+    // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+    var simplified = concat$simplify(element, unconditionalModificationsForTails);
+    var tmp;
+    if (simplified.il_1.m()) {
+      // Inline function 'kotlin.collections.ifEmpty' call
+      var this_1 = simplified.jl_1;
+      // Inline function 'kotlin.contracts.contract' call
+      var tmp_0;
+      if (this_1.m()) {
+        // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>.<anonymous>' call
+        tmp_0 = listOf(simplified);
+      } else {
+        tmp_0 = this_1;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = listOf(simplified);
+    }
+    var list = tmp;
+    addAll(destination, list);
+  }
+  // Inline function 'kotlin.contracts.contract' call
+  var tmp_1;
+  if (destination.m()) {
+    // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+    tmp_1 = listOf(new ParserStructure(unconditionalModificationsForTails, emptyList()));
+  } else {
+    tmp_1 = destination;
+  }
+  var mergedTails = tmp_1;
+  var tmp_2;
+  if (currentNumberSpan == null) {
+    tmp_2 = new ParserStructure(newOperations, mergedTails);
+  } else {
+    var tmp$ret$8;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.none' call
+      var tmp_3;
+      if (isInterface(mergedTails, Collection)) {
+        tmp_3 = mergedTails.m();
+      } else {
+        tmp_3 = false;
+      }
+      if (tmp_3) {
+        tmp$ret$8 = true;
+        break $l$block_0;
+      }
+      var tmp0_iterator_1 = mergedTails.j();
+      while (tmp0_iterator_1.k()) {
+        var element_0 = tmp0_iterator_1.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+        var tmp0_safe_receiver = firstOrNull(element_0.il_1);
+        var tmp_4;
+        if (tmp0_safe_receiver == null) {
+          tmp_4 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          // Inline function 'kotlin.contracts.contract' call
+          // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>.<anonymous>' call
+          tmp_4 = tmp0_safe_receiver instanceof NumberSpanParserOperation;
+        }
+        if (tmp_4 === true) {
+          tmp$ret$8 = false;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$8 = true;
+    }
+    if (tmp$ret$8) {
+      newOperations.e(new NumberSpanParserOperation(currentNumberSpan));
+      tmp_2 = new ParserStructure(newOperations, mergedTails);
+    } else {
+      // Inline function 'kotlin.collections.map' call
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(mergedTails, 10));
+      var tmp0_iterator_2 = mergedTails.j();
+      while (tmp0_iterator_2.k()) {
+        var item = tmp0_iterator_2.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+        var firstOperation = firstOrNull(item.il_1);
+        var tmp_5;
+        if (firstOperation instanceof NumberSpanParserOperation) {
+          tmp_5 = new ParserStructure(plus(listOf(new NumberSpanParserOperation(plus(currentNumberSpan, firstOperation.nl_1))), drop(item.il_1, 1)), item.jl_1);
+        } else {
+          if (firstOperation == null) {
+            tmp_5 = new ParserStructure(listOf(new NumberSpanParserOperation(currentNumberSpan)), item.jl_1);
+          } else {
+            tmp_5 = new ParserStructure(plus(listOf(new NumberSpanParserOperation(currentNumberSpan)), item.il_1), item.jl_1);
+          }
+        }
+        var tmp$ret$12 = tmp_5;
+        destination_0.e(tmp$ret$12);
+      }
+      var newTails = destination_0;
+      tmp_2 = new ParserStructure(newOperations, newTails);
+    }
+  }
+  return tmp_2;
+}
+function formatError$lambda(it) {
+  return 'position ' + it.al_1 + ": '" + it.bl_1() + "'";
+}
+function SignedIntParser(minDigits, maxDigits, spacePadding, setter, name, plusOnExceedsWidth) {
+  var parsers = mutableListOf([spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name, true)]);
+  if (!(plusOnExceedsWidth == null)) {
+    parsers.e(spaceAndZeroPaddedUnsignedInt(minDigits, plusOnExceedsWidth, spacePadding, setter, name));
+    parsers.e(new ParserStructure(listOf_0([new PlainStringParserOperation('+'), new NumberSpanParserOperation(listOf(new UnsignedIntConsumer(plusOnExceedsWidth + 1 | 0, maxDigits, setter, name, false)))]), emptyList()));
+  } else {
+    parsers.e(spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name));
+  }
+  return new ParserStructure(emptyList(), parsers);
+}
+function spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name, withMinus) {
+  withMinus = withMinus === VOID ? false : withMinus;
+  var minNumberLength = (minDigits == null ? 1 : minDigits) + (withMinus ? 1 : 0) | 0;
+  var tmp;
+  if (maxDigits == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.internal.format.parser.spaceAndZeroPaddedUnsignedInt.<anonymous>' call
+    tmp = withMinus ? maxDigits + 1 | 0 : maxDigits;
+  }
+  var tmp2_elvis_lhs = tmp;
+  var maxNumberLength = tmp2_elvis_lhs == null ? 2147483647 : tmp2_elvis_lhs;
+  var spacePadding_0 = spacePadding == null ? 0 : spacePadding;
+  // Inline function 'kotlin.comparisons.minOf' call
+  var maxPaddedNumberLength = Math.min(maxNumberLength, spacePadding_0);
+  if (minNumberLength >= maxPaddedNumberLength)
+    return spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, minNumberLength, maxNumberLength);
+  var accumulated = spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, minNumberLength, minNumberLength);
+  var inductionVariable = minNumberLength;
+  if (inductionVariable < maxPaddedNumberLength)
+    do {
+      var accumulatedWidth = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      accumulated = new ParserStructure(emptyList(), listOf_0([spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, accumulatedWidth + 1 | 0, accumulatedWidth + 1 | 0), concat(listOf_0([new ParserStructure(listOf(new PlainStringParserOperation(' ')), emptyList()), accumulated]))]));
+    }
+     while (inductionVariable < maxPaddedNumberLength);
+  var tmp_0;
+  if (spacePadding_0 > maxNumberLength) {
+    var prepadding = new PlainStringParserOperation(repeat(' ', spacePadding_0 - maxNumberLength | 0));
+    tmp_0 = concat(listOf_0([new ParserStructure(listOf(prepadding), emptyList()), accumulated]));
+  } else if (spacePadding_0 === maxNumberLength) {
+    tmp_0 = accumulated;
+  } else {
+    var r = new ParserStructure(emptyList(), listOf_0([spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, spacePadding_0 + 1 | 0, maxNumberLength), accumulated]));
+    tmp_0 = r;
+  }
+  return tmp_0;
+}
+function _get_whatThisExpects__4pg11j($this) {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = $this.nl_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+  var tmp0_iterator = this_0.j();
+  while (tmp0_iterator.k()) {
+    var item = tmp0_iterator.l();
+    // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<get-whatThisExpects>.<anonymous>' call
+    var length = item.a();
+    var tmp$ret$0 = (length == null ? 'at least one digit' : '' + length + ' digits') + (' for ' + item.ok_1);
+    destination.e(tmp$ret$0);
+  }
+  var consumerLengths = destination;
+  var tmp;
+  if ($this.pl_1) {
+    tmp = 'a number with at least ' + $this.ol_1 + ' digits: ' + toString(consumerLengths);
+  } else {
+    tmp = 'a number with exactly ' + $this.ol_1 + ' digits: ' + toString(consumerLengths);
+  }
+  return tmp;
+}
+function NumberSpanParserOperation$consume$lambda(this$0) {
+  return function () {
+    return 'Unexpected end of input: yet to parse ' + _get_whatThisExpects__4pg11j(this$0);
+  };
+}
+function NumberSpanParserOperation$consume$lambda_0($digitsInRow, this$0) {
+  return function () {
+    return 'Only found ' + $digitsInRow._v + ' digits in a row, but need to parse ' + _get_whatThisExpects__4pg11j(this$0);
+  };
+}
+function NumberSpanParserOperation$consume$lambda_1($numberString, this$0, $i, $error) {
+  return function () {
+    return "Can not interpret the string '" + $numberString + "' as " + this$0.nl_1.n($i).ok_1 + ': ' + $error.pk();
+  };
+}
+function NumberSpanParserOperation(consumers) {
+  this.nl_1 = consumers;
+  var tmp = this;
+  // Inline function 'kotlin.collections.sumOf' call
+  var sum = 0;
+  var tmp0_iterator = this.nl_1.j();
+  while (tmp0_iterator.k()) {
+    var element = tmp0_iterator.l();
+    var tmp_0 = sum;
+    // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.minLength.<anonymous>' call
+    var tmp0_elvis_lhs = element.a();
+    sum = tmp_0 + (tmp0_elvis_lhs == null ? 1 : tmp0_elvis_lhs) | 0;
+  }
+  tmp.ol_1 = sum;
+  var tmp_1 = this;
+  var tmp$ret$2;
+  $l$block_0: {
+    // Inline function 'kotlin.collections.any' call
+    var this_0 = this.nl_1;
+    var tmp_2;
+    if (isInterface(this_0, Collection)) {
+      tmp_2 = this_0.m();
+    } else {
+      tmp_2 = false;
+    }
+    if (tmp_2) {
+      tmp$ret$2 = false;
+      break $l$block_0;
+    }
+    var tmp0_iterator_0 = this_0.j();
+    while (tmp0_iterator_0.k()) {
+      var element_0 = tmp0_iterator_0.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.isFlexible.<anonymous>' call
+      if (element_0.a() == null) {
+        tmp$ret$2 = true;
+        break $l$block_0;
+      }
+    }
+    tmp$ret$2 = false;
+  }
+  tmp_1.pl_1 = tmp$ret$2;
+  // Inline function 'kotlin.require' call
+  var tmp$ret$4;
+  $l$block_2: {
+    // Inline function 'kotlin.collections.all' call
+    var this_1 = this.nl_1;
+    var tmp_3;
+    if (isInterface(this_1, Collection)) {
+      tmp_3 = this_1.m();
+    } else {
+      tmp_3 = false;
+    }
+    if (tmp_3) {
+      tmp$ret$4 = true;
+      break $l$block_2;
+    }
+    var tmp0_iterator_1 = this_1.j();
+    while (tmp0_iterator_1.k()) {
+      var element_1 = tmp0_iterator_1.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>' call
+      var tmp0_elvis_lhs_0 = element_1.a();
+      if (!((tmp0_elvis_lhs_0 == null ? 2147483647 : tmp0_elvis_lhs_0) > 0)) {
+        tmp$ret$4 = false;
+        break $l$block_2;
+      }
+    }
+    tmp$ret$4 = true;
+  }
+  // Inline function 'kotlin.contracts.contract' call
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!tmp$ret$4) {
+    // Inline function 'kotlin.require.<anonymous>' call
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  var tmp$ret$7;
+  $l$block_3: {
+    // Inline function 'kotlin.collections.count' call
+    var this_2 = this.nl_1;
+    var tmp_4;
+    if (isInterface(this_2, Collection)) {
+      tmp_4 = this_2.m();
+    } else {
+      tmp_4 = false;
+    }
+    if (tmp_4) {
+      tmp$ret$7 = 0;
+      break $l$block_3;
+    }
+    var count = 0;
+    var tmp0_iterator_2 = this_2.j();
+    while (tmp0_iterator_2.k()) {
+      var element_2 = tmp0_iterator_2.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>' call
+      if (element_2.a() == null) {
+        count = count + 1 | 0;
+        checkCountOverflow(count);
+      }
+    }
+    tmp$ret$7 = count;
+  }
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(tmp$ret$7 <= 1)) {
+    // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>' call
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var this_3 = this.nl_1;
+    var destination = ArrayList_init_$Create$();
+    var tmp0_iterator_3 = this_3.j();
+    while (tmp0_iterator_3.k()) {
+      var element_3 = tmp0_iterator_3.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>.<anonymous>' call
+      if (element_3.a() == null) {
+        destination.e(element_3);
+      }
+    }
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(destination, 10));
+    var tmp0_iterator_4 = destination.j();
+    while (tmp0_iterator_4.k()) {
+      var item = tmp0_iterator_4.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>.<anonymous>' call
+      var tmp$ret$12 = item.ok_1;
+      destination_0.e(tmp$ret$12);
+    }
+    var fieldNames = destination_0;
+    var message_0 = 'At most one variable-length numeric field in a row is allowed, but got several: ' + toString(fieldNames) + '. ' + 'Parsing is undefined: for example, with variable-length month number ' + "and variable-length day of month, '111' can be parsed as Jan 11th or Nov 1st.";
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+protoOf(NumberSpanParserOperation).kl = function (storage, input, startIndex) {
+  if ((startIndex + this.ol_1 | 0) > charSequenceLength(input)) {
+    var tmp = Companion_instance_2;
+    return tmp.dl(startIndex, NumberSpanParserOperation$consume$lambda(this));
+  }
+  var digitsInRow = {_v: 0};
+  while ((startIndex + digitsInRow._v | 0) < charSequenceLength(input) && isAsciiDigit(charSequenceGet(input, startIndex + digitsInRow._v | 0))) {
+    digitsInRow._v = digitsInRow._v + 1 | 0;
+    digitsInRow._v;
+  }
+  if (digitsInRow._v < this.ol_1) {
+    var tmp_0 = Companion_instance_2;
+    return tmp_0.dl(startIndex, NumberSpanParserOperation$consume$lambda_0(digitsInRow, this));
+  }
+  var index = startIndex;
+  var inductionVariable = 0;
+  var last = this.nl_1.o() - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp1_elvis_lhs = this.nl_1.n(i).a();
+      var length = tmp1_elvis_lhs == null ? (digitsInRow._v - this.ol_1 | 0) + 1 | 0 : tmp1_elvis_lhs;
+      var error = this.nl_1.n(i).mk(storage, input, index, index + length | 0);
+      if (!(error == null)) {
+        // Inline function 'kotlin.text.substring' call
+        var startIndex_0 = index;
+        var endIndex = index + length | 0;
+        var numberString = toString(charSequenceSubSequence(input, startIndex_0, endIndex));
+        var tmp_1 = Companion_instance_2;
+        var tmp_2 = index;
+        return tmp_1.dl(tmp_2, NumberSpanParserOperation$consume$lambda_1(numberString, this, i, error));
+      }
+      index = index + length | 0;
+    }
+     while (inductionVariable <= last);
+  return Companion_instance_2.cl(index);
+};
+protoOf(NumberSpanParserOperation).toString = function () {
+  return _get_whatThisExpects__4pg11j(this);
+};
+function PlainStringParserOperation$consume$lambda(this$0) {
+  return function () {
+    return "Unexpected end of input: yet to parse '" + this$0.ql_1 + "'";
+  };
+}
+function PlainStringParserOperation$consume$lambda_0(this$0, $input, $startIndex, $i) {
+  return function () {
+    // Inline function 'kotlin.text.substring' call
+    var this_0 = $input;
+    var startIndex = $startIndex;
+    var endIndex = ($startIndex + $i | 0) + 1 | 0;
+    var tmp$ret$0 = toString(charSequenceSubSequence(this_0, startIndex, endIndex));
+    return 'Expected ' + this$0.ql_1 + ' but got ' + tmp$ret$0;
+  };
+}
+function PlainStringParserOperation(string) {
+  this.ql_1 = string;
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.text.isNotEmpty' call
+  var this_0 = this.ql_1;
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(charSequenceLength(this_0) > 0)) {
+    // Inline function 'kotlinx.datetime.internal.format.parser.PlainStringParserOperation.<anonymous>' call
+    var message = 'Empty string is not allowed';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!!isAsciiDigit(charSequenceGet(this.ql_1, 0))) {
+    // Inline function 'kotlinx.datetime.internal.format.parser.PlainStringParserOperation.<anonymous>' call
+    var message_0 = "String '" + this.ql_1 + "' starts with a digit";
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!!isAsciiDigit(charSequenceGet(this.ql_1, this.ql_1.length - 1 | 0))) {
+    // Inline function 'kotlinx.datetime.internal.format.parser.PlainStringParserOperation.<anonymous>' call
+    var message_1 = "String '" + this.ql_1 + "' ends with a digit";
+    throw IllegalArgumentException_init_$Create$(toString(message_1));
+  }
+}
+protoOf(PlainStringParserOperation).kl = function (storage, input, startIndex) {
+  if ((startIndex + this.ql_1.length | 0) > charSequenceLength(input)) {
+    var tmp = Companion_instance_2;
+    return tmp.dl(startIndex, PlainStringParserOperation$consume$lambda(this));
+  }
+  var inductionVariable = 0;
+  var last = charSequenceLength(this.ql_1) - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      if (!(charSequenceGet(input, startIndex + i | 0) === charSequenceGet(this.ql_1, i))) {
+        var tmp_0 = Companion_instance_2;
+        return tmp_0.dl(startIndex, PlainStringParserOperation$consume$lambda_0(this, input, startIndex, i));
+      }
+    }
+     while (inductionVariable <= last);
+  return Companion_instance_2.cl(startIndex + this.ql_1.length | 0);
+};
+protoOf(PlainStringParserOperation).toString = function () {
+  return "'" + this.ql_1 + "'";
+};
+function UnconditionalModification() {
+}
+function spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths($withMinus, $setter, $name, minNumberLength, maxNumberLength) {
+  // Inline function 'kotlin.check' call
+  // Inline function 'kotlin.contracts.contract' call
+  // Inline function 'kotlin.check' call
+  // Inline function 'kotlin.contracts.contract' call
+  if (!(maxNumberLength >= (1 + ($withMinus ? 1 : 0) | 0))) {
+    // Inline function 'kotlin.check.<anonymous>' call
+    var message = 'Check failed.';
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.collections.buildList' call
+  // Inline function 'kotlin.contracts.contract' call
+  // Inline function 'kotlin.collections.buildListInternal' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = ArrayList_init_$Create$();
+  // Inline function 'kotlin.contracts.contract' call
+  // Inline function 'kotlinx.datetime.internal.format.parser.spaceAndZeroPaddedUnsignedInt.numberOfRequiredLengths.<anonymous>' call
+  if ($withMinus) {
+    this_0.e(new PlainStringParserOperation('-'));
+  }
+  this_0.e(new NumberSpanParserOperation(listOf(new UnsignedIntConsumer(minNumberLength - ($withMinus ? 1 : 0) | 0, maxNumberLength - ($withMinus ? 1 : 0) | 0, $setter, $name, $withMinus))));
+  var tmp$ret$3 = this_0.d5();
+  return new ParserStructure(tmp$ret$3, emptyList());
+}
+function isAsciiDigit(_this__u8e3s4) {
+  return _Char___init__impl__6a9atx(48) <= _this__u8e3s4 ? _this__u8e3s4 <= _Char___init__impl__6a9atx(57) : false;
+}
+function asciiDigitToInt(_this__u8e3s4) {
+  return Char__minus_impl_a2frrh(_this__u8e3s4, _Char___init__impl__6a9atx(48));
+}
+var DayOfWeek_MONDAY_instance;
+var DayOfWeek_TUESDAY_instance;
+var DayOfWeek_WEDNESDAY_instance;
+var DayOfWeek_THURSDAY_instance;
+var DayOfWeek_FRIDAY_instance;
+var DayOfWeek_SATURDAY_instance;
+var DayOfWeek_SUNDAY_instance;
+function values() {
+  return [DayOfWeek_MONDAY_getInstance(), DayOfWeek_TUESDAY_getInstance(), DayOfWeek_WEDNESDAY_getInstance(), DayOfWeek_THURSDAY_getInstance(), DayOfWeek_FRIDAY_getInstance(), DayOfWeek_SATURDAY_getInstance(), DayOfWeek_SUNDAY_getInstance()];
+}
+function get_entries() {
+  if ($ENTRIES == null)
+    $ENTRIES = enumEntries(values());
+  return $ENTRIES;
+}
+var DayOfWeek_entriesInitialized;
+function DayOfWeek_initEntries() {
+  if (DayOfWeek_entriesInitialized)
+    return Unit_instance;
+  DayOfWeek_entriesInitialized = true;
+  DayOfWeek_MONDAY_instance = new DayOfWeek_0('MONDAY', 0);
+  DayOfWeek_TUESDAY_instance = new DayOfWeek_0('TUESDAY', 1);
+  DayOfWeek_WEDNESDAY_instance = new DayOfWeek_0('WEDNESDAY', 2);
+  DayOfWeek_THURSDAY_instance = new DayOfWeek_0('THURSDAY', 3);
+  DayOfWeek_FRIDAY_instance = new DayOfWeek_0('FRIDAY', 4);
+  DayOfWeek_SATURDAY_instance = new DayOfWeek_0('SATURDAY', 5);
+  DayOfWeek_SUNDAY_instance = new DayOfWeek_0('SUNDAY', 6);
+}
+var $ENTRIES;
+function DayOfWeek_0(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function toDayOfWeek(_this__u8e3s4) {
+  return DayOfWeek(_this__u8e3s4.value());
+}
+function DayOfWeek_MONDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_MONDAY_instance;
+}
+function DayOfWeek_TUESDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_TUESDAY_instance;
+}
+function DayOfWeek_WEDNESDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_WEDNESDAY_instance;
+}
+function DayOfWeek_THURSDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_THURSDAY_instance;
+}
+function DayOfWeek_FRIDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_FRIDAY_instance;
+}
+function DayOfWeek_SATURDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_SATURDAY_instance;
+}
+function DayOfWeek_SUNDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_SUNDAY_instance;
+}
+function Instant() {
+}
+function isJodaDateTimeParseException(_this__u8e3s4) {
+  return hasJsExceptionName(_this__u8e3s4, 'DateTimeParseException');
+}
+function isJodaDateTimeException(_this__u8e3s4) {
+  return hasJsExceptionName(_this__u8e3s4, 'DateTimeException');
+}
+function isJodaArithmeticException(_this__u8e3s4) {
+  return hasJsExceptionName(_this__u8e3s4, 'ArithmeticException');
+}
+function Companion_3() {
+  Companion_instance_3 = this;
+  this.rl_1 = new LocalDate_0(LocalDate.MIN);
+  this.sl_1 = new LocalDate_0(LocalDate.MAX);
+}
+protoOf(Companion_3).tl = function (input, format) {
+  var tmp;
+  if (format === Formats_getInstance().lg()) {
+    var tmp_0;
+    try {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlinx.datetime.jsTry' call
+      // Inline function 'kotlinx.datetime.Companion.parse.<anonymous>' call
+      // Inline function 'kotlin.contracts.contract' call
+      var p0 = LocalDate.parse(toString(input));
+      tmp_0 = new LocalDate_0(p0);
+    } catch ($p) {
+      var tmp_1;
+      if ($p instanceof Error) {
+        var e = $p;
+        if (isJodaDateTimeParseException(e))
+          throw DateTimeFormatException_init_$Create$_1(e);
+        throw e;
+      } else {
+        throw $p;
+      }
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = format.pg(input);
+  }
+  return tmp;
+};
+protoOf(Companion_3).ul = function (input, format, $super) {
+  format = format === VOID ? getIsoDateFormat() : format;
+  return $super === VOID ? this.tl(input, format) : $super.tl.call(this, input, format);
+};
+var Companion_instance_3;
+function Companion_getInstance_3() {
+  if (Companion_instance_3 == null)
+    new Companion_3();
+  return Companion_instance_3;
+}
+function Formats() {
+  Formats_instance = this;
+  this.kg_1 = get_ISO_DATE_BASIC();
+}
+protoOf(Formats).lg = function () {
+  return get_ISO_DATE();
+};
+var Formats_instance;
+function Formats_getInstance() {
+  if (Formats_instance == null)
+    new Formats();
+  return Formats_instance;
+}
+function LocalDate_init_$Init$(year, monthNumber, dayOfMonth, $this) {
+  var tmp;
+  try {
+    // Inline function 'kotlinx.datetime.jsTry' call
+    // Inline function 'kotlinx.datetime.LocalDate.<init>.<anonymous>' call
+    tmp = LocalDate.of(year, monthNumber, dayOfMonth);
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof Error) {
+      var e = $p;
+      if (isJodaDateTimeException(e))
+        throw IllegalArgumentException_init_$Create$_0(e);
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  LocalDate_0.call($this, tmp);
+  return $this;
+}
+function LocalDate_init_$Create$(year, monthNumber, dayOfMonth) {
+  return LocalDate_init_$Init$(year, monthNumber, dayOfMonth, objectCreate(protoOf(LocalDate_0)));
+}
+function LocalDate_0(value) {
+  Companion_getInstance_3();
+  this.th_1 = value;
+}
+protoOf(LocalDate_0).uh = function () {
+  return toDayOfWeek(this.th_1.dayOfWeek());
+};
+protoOf(LocalDate_0).equals = function (other) {
+  var tmp;
+  if (this === other) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    if (other instanceof LocalDate_0) {
+      tmp_0 = this.th_1 === other.th_1 || this.th_1.equals(other.th_1);
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(LocalDate_0).hashCode = function () {
+  return this.th_1.hashCode();
+};
+protoOf(LocalDate_0).toString = function () {
+  return this.th_1.toString();
+};
+protoOf(LocalDate_0).vl = function (other) {
+  return this.th_1.compareTo(other.th_1);
+};
+protoOf(LocalDate_0).d = function (other) {
+  return this.vl(other instanceof LocalDate_0 ? other : THROW_CCE());
+};
+protoOf(LocalDate_0).wl = function () {
+  return numberToInt(this.th_1.toEpochDay());
+};
+function plus_0(_this__u8e3s4, period) {
+  var tmp;
+  try {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.with' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.plus.<anonymous>' call
+    // Inline function 'kotlin.run' call
+    // Inline function 'kotlin.run' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>' call
+    var $this$run = _this__u8e3s4.th_1;
+    var tmp_0;
+    if (!(period.zf_1 === 0)) {
+      // Inline function 'kotlinx.datetime.jsTry' call
+      // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>.<anonymous>' call
+      tmp_0 = $this$run.plusMonths(period.zf_1);
+    } else {
+      tmp_0 = $this$run;
+    }
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>' call
+    var $this$run_0 = tmp_0;
+    var tmp_1;
+    if (!(period.ag_1 === 0)) {
+      // Inline function 'kotlinx.datetime.jsTry' call
+      // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>.<anonymous>' call
+      tmp_1 = $this$run_0.plusDays(period.ag_1);
+    } else {
+      tmp_1 = $this$run_0;
+    }
+    // Inline function 'kotlin.contracts.contract' call
+    var p0 = tmp_1;
+    tmp = new LocalDate_0(p0);
+  } catch ($p) {
+    var tmp_2;
+    if ($p instanceof Error) {
+      var e = $p;
+      if (isJodaDateTimeException(e) || isJodaArithmeticException(e))
+        throw DateTimeArithmeticException_init_$Create$_0(e);
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return tmp;
+}
+function daysUntil(_this__u8e3s4, other) {
+  return numberToInt(_this__u8e3s4.th_1.until(other.th_1, ChronoUnit.DAYS));
+}
+function monthsUntil(_this__u8e3s4, other) {
+  return numberToInt(_this__u8e3s4.th_1.until(other.th_1, ChronoUnit.MONTHS));
+}
+function yearsUntil(_this__u8e3s4, other) {
+  return numberToInt(_this__u8e3s4.th_1.until(other.th_1, ChronoUnit.YEARS));
+}
+function Companion_4() {
+  Companion_instance_4 = this;
+  this.xl_1 = new LocalDateTime_0(LocalDateTime.MIN);
+  this.yl_1 = new LocalDateTime_0(LocalDateTime.MAX);
+}
+var Companion_instance_4;
+function Companion_getInstance_4() {
+  if (Companion_instance_4 == null)
+    new Companion_4();
+  return Companion_instance_4;
+}
+function LocalDateTime_0(value) {
+  Companion_getInstance_4();
+  this.zl_1 = value;
+}
+protoOf(LocalDateTime_0).am = function () {
+  return new LocalDate_0(this.zl_1.toLocalDate());
+};
+protoOf(LocalDateTime_0).equals = function (other) {
+  var tmp;
+  if (this === other) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    if (other instanceof LocalDateTime_0) {
+      tmp_0 = this.zl_1 === other.zl_1 || this.zl_1.equals(other.zl_1);
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(LocalDateTime_0).hashCode = function () {
+  return this.zl_1.hashCode();
+};
+protoOf(LocalDateTime_0).toString = function () {
+  return this.zl_1.toString();
+};
+protoOf(LocalDateTime_0).bm = function (other) {
+  return this.zl_1.compareTo(other.zl_1);
+};
+protoOf(LocalDateTime_0).d = function (other) {
+  return this.bm(other instanceof LocalDateTime_0 ? other : THROW_CCE());
+};
+function ofZone($this, zoneId) {
+  var tmp;
+  if (zoneId instanceof ZoneOffset) {
+    tmp = FixedOffsetTimeZone_init_$Create$(new UtcOffset(zoneId));
+  } else {
+    if (zoneId.rules().isFixedOffset()) {
+      var tmp_0 = zoneId.normalized();
+      tmp = new FixedOffsetTimeZone(new UtcOffset(tmp_0 instanceof ZoneOffset ? tmp_0 : THROW_CCE()), zoneId);
+    } else {
+      tmp = new TimeZone(zoneId);
+    }
+  }
+  return tmp;
+}
+function Companion_5() {
+  Companion_instance_5 = this;
+  this.cm_1 = asTimeZone(new UtcOffset(ZoneOffset.UTC));
+}
+protoOf(Companion_5).dm = function () {
+  return ofZone(this, ZoneId.systemDefault());
+};
+var Companion_instance_5;
+function Companion_getInstance_5() {
+  if (Companion_instance_5 == null)
+    new Companion_5();
+  return Companion_instance_5;
+}
+function TimeZone(zoneId) {
+  Companion_getInstance_5();
+  this.em_1 = zoneId;
+}
+protoOf(TimeZone).equals = function (other) {
+  var tmp;
+  if (this === other) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    if (other instanceof TimeZone) {
+      tmp_0 = this.em_1 === other.em_1 || this.em_1.equals(other.em_1);
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(TimeZone).hashCode = function () {
+  return this.em_1.hashCode();
+};
+protoOf(TimeZone).toString = function () {
+  return this.em_1.toString();
+};
+function toLocalDateTime(_this__u8e3s4, timeZone) {
+  var tmp;
+  try {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlinx.datetime.jsTry' call
+    // Inline function 'kotlinx.datetime.toLocalDateTime.<anonymous>' call
+    // Inline function 'kotlin.contracts.contract' call
+    var p0 = LocalDateTime.ofInstant(_this__u8e3s4.fm_1, timeZone.em_1);
+    tmp = new LocalDateTime_0(p0);
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof Error) {
+      var e = $p;
+      if (isJodaDateTimeException(e))
+        throw DateTimeArithmeticException_init_$Create$_0(e);
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+  return tmp;
+}
+function FixedOffsetTimeZone_init_$Init$(offset, $this) {
+  FixedOffsetTimeZone.call($this, offset, offset.gm_1);
+  return $this;
+}
+function FixedOffsetTimeZone_init_$Create$(offset) {
+  return FixedOffsetTimeZone_init_$Init$(offset, objectCreate(protoOf(FixedOffsetTimeZone)));
+}
+function Companion_6() {
+}
+var Companion_instance_6;
+function Companion_getInstance_6() {
+  return Companion_instance_6;
+}
+function FixedOffsetTimeZone(offset, zoneId) {
+  TimeZone.call(this, zoneId);
+  this.im_1 = offset;
+}
+function Companion_7() {
+  Companion_instance_7 = this;
+  this.jm_1 = new UtcOffset(ZoneOffset.UTC);
+}
+var Companion_instance_7;
+function Companion_getInstance_7() {
+  if (Companion_instance_7 == null)
+    new Companion_7();
+  return Companion_instance_7;
+}
+function UtcOffset(zoneOffset) {
+  Companion_getInstance_7();
+  this.gm_1 = zoneOffset;
+}
+protoOf(UtcOffset).hashCode = function () {
+  return this.gm_1.hashCode();
+};
+protoOf(UtcOffset).equals = function (other) {
+  var tmp;
+  if (other instanceof UtcOffset) {
+    tmp = this.gm_1 === other.gm_1 || this.gm_1.equals(other.gm_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(UtcOffset).toString = function () {
+  return this.gm_1.toString();
+};
+function hasJsExceptionName(_this__u8e3s4, name) {
+  // Inline function 'kotlin.js.asDynamic' call
+  return _this__u8e3s4.name == name;
+}
+//region block: post-declaration
+protoOf(Builder).ah = chars;
+protoOf(Builder).eh = build;
+protoOf(Builder).ug = year;
+protoOf(Builder).vg = year$default;
+protoOf(Builder).wg = monthNumber;
+protoOf(Builder).xg = monthNumber$default;
+protoOf(Builder).yg = dayOfMonth;
+protoOf(Builder).zg = dayOfMonth$default;
+protoOf(PropertyAccessor).gj = getterNotNull;
+//endregion
+//region block: init
+Companion_instance = new Companion();
+Companion_instance_0 = new Companion_0();
+Companion_instance_1 = new Companion_1();
+ExpectedInt_instance = new ExpectedInt();
+Companion_instance_2 = new Companion_2();
+Companion_instance_6 = new Companion_6();
+//endregion
+//region block: exports
+export {
+  DatePeriod_init_$Create$ as DatePeriod_init_$Create$pxdfqo7eaqju,
+  Companion_getInstance_3 as Companion_getInstancehhs08a75ybhj,
+  Companion_getInstance_5 as Companion_getInstancefmyaurjojj7x,
+  Instant as Instant3cn81rq2kpflk,
+  LocalDate_0 as LocalDate31mqn6zavbpi8,
+  daysUntil as daysUntili13lhjyhczcn,
+  monthsUntil as monthsUntil3ipc0mlqu40r9,
+  plus_0 as plus1oi9f9vif99u2,
+  toLocalDateTime as toLocalDateTime3u4c8ydzr4ubp,
+  yearsUntil as yearsUntil1qbvcre5j21z1,
+};
+//endregion
+
+//# sourceMappingURL=Kotlin-DateTime-library-kotlinx-datetime.mjs.map