@attocash/commons-js 5.0.0

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

@@ -0,0 +1,864 @@
+import {
+  KProperty02ce7r476m8633 as KProperty0,
+  KMutableProperty11e8g1gb0ecb9j as KMutableProperty1,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/reflect/KPropertyJs.mjs';
+import { getPropertyCallableRef1ajb9in178r5r as getPropertyCallableRef } from '../../../../kotlin-kotlin-stdlib/kotlin/js/reflectRuntime.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  LocalDate31mqn6zavbpi8 as LocalDate,
+  plus1et5dysousgt9 as plus,
+} from '../LocalDate.mjs';
+import { Companion_getInstance1hjnoi8x2xjhl as Companion_getInstance } from '../DateTimeUnit.mjs';
+import { DateTimeFormatException2onfeknbywaob as DateTimeFormatException } from '../Exceptions.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  DayOfWeek2xlo40o03f5e as DayOfWeek,
+  get_isoDayNumberrycq4er3aoh9 as get_isoDayNumber,
+} from '../DayOfWeek.mjs';
+import {
+  hashCodeq5arwsb9dgti as hashCode,
+  toString1pkumu07cwy4m as toString,
+  equals2au1ep9vhcato as equals,
+  protoOf180f3jzyo7rfj as protoOf,
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import {
+  listOf1jh22dvmctj1r as listOf,
+  get_indices3txodfl5wuu5j as get_indices,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { charSequenceLength3278n89t01tmv as charSequenceLength } from '../../../../kotlin-kotlin-stdlib/kotlin/js/charSequenceJs.mjs';
+import { joinToString1cxrrlmo0chqs as joinToString } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { AppendableFormatStructure38mt32f1b8qva as AppendableFormatStructure } from '../internal/format/Builder.mjs';
+import {
+  appendAlternativeParsingImpl1mug8j87kp2j3 as appendAlternativeParsingImpl,
+  appendOptionalImplcg29ds00y54b as appendOptionalImpl,
+  chars1g48a4lypizqb as chars,
+  build284bs2tzkjm2x as build,
+  year$defaulto1ef087ubfdc as year$default,
+  monthNumber$default3k7qk403bnffp as monthNumber$default,
+  dayOfMonth$default2fd2gjqoxzh9x as dayOfMonth$default,
+  AbstractDateTimeFormatBuilder2kkelk07l4wb as AbstractDateTimeFormatBuilder,
+  WithDate2bqihss8t5xfv as WithDate,
+  char1r4ssccmdfesy as char,
+} from './DateTimeFormatBuilder.mjs';
+import {
+  AbstractDateTimeFormat1er9ki1vjeb1b as AbstractDateTimeFormat,
+  Padding_ZERO_getInstance2hdjif6phlc74 as Padding_ZERO_getInstance,
+  Padding_SPACE_getInstance7fwkzb4da6c as Padding_SPACE_getInstance,
+} from './DateTimeFormat.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { BasicFormatStructure1rp1tyv3u2fjw as BasicFormatStructure } from '../internal/format/FormatStructure.mjs';
+import {
+  SignedIntFieldFormatDirective2ce7tjucbhgd2 as SignedIntFieldFormatDirective,
+  UnsignedIntFieldFormatDirective20kfpdbszyixg as UnsignedIntFieldFormatDirective,
+  NamedUnsignedIntFieldFormatDirective1yq6ki9eqgm4v as NamedUnsignedIntFieldFormatDirective,
+} from '../internal/format/FieldFormatDirective.mjs';
+import {
+  PropertyAccessor1m9zk65ebkfc4 as PropertyAccessor,
+  GenericFieldSpecnllvuuqbuxsd as GenericFieldSpec,
+  UnsignedFieldSpec1pqzij1hidkca as UnsignedFieldSpec,
+} from '../internal/format/FieldSpec.mjs';
+import { _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { lazy2hsh8ze7j6ikd as lazy } from '../../../../kotlin-kotlin-stdlib/kotlin/kotlin.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function get_ISO_DATE() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp0 = ISO_DATE$delegate;
+  var tmp = KProperty0();
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('ISO_DATE', 0, tmp, _get_ISO_DATE_$ref_powsum(), null);
+  return tmp0.s1();
+}
+var ISO_DATE$delegate;
+function get_ISO_DATE_BASIC() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp0 = ISO_DATE_BASIC$delegate;
+  var tmp = KProperty0();
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('ISO_DATE_BASIC', 0, tmp, _get_ISO_DATE_BASIC_$ref_3fs8eb(), null);
+  return tmp0.s1();
+}
+var ISO_DATE_BASIC$delegate;
+function get_emptyIncompleteLocalDate() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  return emptyIncompleteLocalDate;
+}
+var emptyIncompleteLocalDate;
+var IncompleteLocalDateClass;
+function IncompleteLocalDate() {
+  if (IncompleteLocalDateClass === VOID) {
+    class $ {
+      constructor(year, monthNumber, dayOfMonth, isoDayOfWeek, dayOfYear) {
+        year = year === VOID ? null : year;
+        monthNumber = monthNumber === VOID ? null : monthNumber;
+        dayOfMonth = dayOfMonth === VOID ? null : dayOfMonth;
+        isoDayOfWeek = isoDayOfWeek === VOID ? null : isoDayOfWeek;
+        dayOfYear = dayOfYear === VOID ? null : dayOfYear;
+        this.m1g_1 = year;
+        this.n1g_1 = monthNumber;
+        this.o1g_1 = dayOfMonth;
+        this.p1g_1 = isoDayOfWeek;
+        this.q1g_1 = dayOfYear;
+      }
+      y1g(_set____db54di) {
+        this.m1g_1 = _set____db54di;
+      }
+      z1g() {
+        return this.m1g_1;
+      }
+      w1g(_set____db54di) {
+        this.n1g_1 = _set____db54di;
+      }
+      x1g() {
+        return this.n1g_1;
+      }
+      l1g(_set____db54di) {
+        this.o1g_1 = _set____db54di;
+      }
+      r1g() {
+        return this.o1g_1;
+      }
+      u1g(_set____db54di) {
+        this.p1g_1 = _set____db54di;
+      }
+      v1g() {
+        return this.p1g_1;
+      }
+      s1g(_set____db54di) {
+        this.q1g_1 = _set____db54di;
+      }
+      t1g() {
+        return this.q1g_1;
+      }
+      u1j() {
+        var year = requireParsedField(this.m1g_1, 'year');
+        var dayOfYear = this.q1g_1;
+        var tmp;
+        if (dayOfYear == null) {
+          tmp = LocalDate().p1l(year, requireParsedField(this.n1g_1, 'monthNumber'), requireParsedField(this.o1g_1, 'dayOfMonth'));
+        } else {
+          // Inline function 'kotlin.also' call
+          var this_0 = plus(LocalDate().p1l(year, 1, 1), dayOfYear - 1 | 0, Companion_getInstance().b1f_1);
+          if (!(this_0.z1g() === year)) {
+            throw DateTimeFormatException().m1f('Can not create a LocalDate from the given input: ' + ('the day of year is ' + dayOfYear + ', which is not a valid day of year for the year ' + year));
+          }
+          if (!(this.n1g_1 == null) && !(this_0.x1g() === this.n1g_1)) {
+            throw DateTimeFormatException().m1f('Can not create a LocalDate from the given input: ' + ('the day of year is ' + dayOfYear + ', which is ' + this_0.q1l().toString() + ', ') + ('but ' + this.n1g_1 + ' was specified as the month number'));
+          }
+          if (!(this.o1g_1 == null) && !(this_0.r1g() === this.o1g_1)) {
+            throw DateTimeFormatException().m1f('Can not create a LocalDate from the given input: ' + ('the day of year is ' + dayOfYear + ', which is the day ' + this_0.r1g() + ' of ' + this_0.q1l().toString() + ', ') + ('but ' + this.o1g_1 + ' was specified as the day of month'));
+          }
+          tmp = this_0;
+        }
+        var date = tmp;
+        var tmp0_safe_receiver = this.p1g_1;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          if (!(tmp0_safe_receiver === get_isoDayNumber(date.r1l()))) {
+            throw DateTimeFormatException().m1f('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.r1l().toString()));
+          }
+        }
+        return date;
+      }
+      g1i() {
+        return new (IncompleteLocalDate())(this.m1g_1, this.n1g_1, this.o1g_1, this.p1g_1, this.q1g_1);
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        var tmp_1;
+        var tmp_2;
+        var tmp_3;
+        if (other instanceof IncompleteLocalDate()) {
+          tmp_3 = this.m1g_1 == other.m1g_1;
+        } else {
+          tmp_3 = false;
+        }
+        if (tmp_3) {
+          tmp_2 = this.n1g_1 == other.n1g_1;
+        } else {
+          tmp_2 = false;
+        }
+        if (tmp_2) {
+          tmp_1 = this.o1g_1 == other.o1g_1;
+        } else {
+          tmp_1 = false;
+        }
+        if (tmp_1) {
+          tmp_0 = this.p1g_1 == other.p1g_1;
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = this.q1g_1 == other.q1g_1;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver = this.m1g_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, 923521);
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver_0 = this.n1g_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, 29791) | 0;
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver_1 = this.o1g_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, 961) | 0;
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver_2 = this.p1g_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;
+        var tmp_2 = tmp_1 + imul(tmp$ret$3, 31) | 0;
+        // Inline function 'kotlin.hashCode' call
+        var tmp0_safe_receiver_3 = this.q1g_1;
+        var tmp1_elvis_lhs_3 = tmp0_safe_receiver_3 == null ? null : hashCode(tmp0_safe_receiver_3);
+        return tmp_2 + (tmp1_elvis_lhs_3 == null ? 0 : tmp1_elvis_lhs_3) | 0;
+      }
+      toString() {
+        var tmp0_elvis_lhs = this.m1g_1;
+        var tmp = toString(tmp0_elvis_lhs == null ? '??' : tmp0_elvis_lhs);
+        var tmp1_elvis_lhs = this.n1g_1;
+        var tmp_0 = toString(tmp1_elvis_lhs == null ? '??' : tmp1_elvis_lhs);
+        var tmp2_elvis_lhs = this.o1g_1;
+        var tmp_1 = toString(tmp2_elvis_lhs == null ? '??' : tmp2_elvis_lhs);
+        var tmp3_elvis_lhs = this.p1g_1;
+        return tmp + '-' + tmp_0 + '-' + tmp_1 + ' (day of week is ' + toString(tmp3_elvis_lhs == null ? '??' : tmp3_elvis_lhs) + ')';
+      }
+    }
+    initMetadataForClass($, 'IncompleteLocalDate', IncompleteLocalDate);
+    IncompleteLocalDateClass = $;
+  }
+  return IncompleteLocalDateClass;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.p1i_1 = new (MonthNames())(listOf(['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']));
+        this.q1i_1 = new (MonthNames())(listOf(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']));
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+function String$toString$ref() {
+  var l = function (p0) {
+    return toString(p0);
+  };
+  l.callableName = 'toString';
+  return l;
+}
+var MonthNamesClass;
+function MonthNames() {
+  if (MonthNamesClass === VOID) {
+    class $ {
+      constructor(names) {
+        Companion_getInstance_0();
+        this.s1l_1 = names;
+        // Inline function 'kotlin.require' call
+        if (!(this.s1l_1.i1() === 12)) {
+          var message = 'Month names must contain exactly 12 elements';
+          throw IllegalArgumentException().u(toString(message));
+        }
+        // Inline function 'kotlin.collections.forEach' call
+        var progression = get_indices(this.s1l_1);
+        var inductionVariable = progression.u1_1;
+        var last = progression.v1_1;
+        if (inductionVariable <= last)
+          do {
+            var element = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var ix = element;
+            // Inline function 'kotlin.text.isNotEmpty' call
+            var this_0 = this.s1l_1.j1(ix);
+            // Inline function 'kotlin.require' call
+            if (!(charSequenceLength(this_0) > 0)) {
+              var message_0 = 'A month name can not be empty';
+              throw IllegalArgumentException().u(toString(message_0));
+            }
+            var inductionVariable_0 = 0;
+            if (inductionVariable_0 < ix)
+              do {
+                var ix2 = inductionVariable_0;
+                inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                // Inline function 'kotlin.require' call
+                if (!!(this.s1l_1.j1(ix) === this.s1l_1.j1(ix2))) {
+                  var message_1 = "Month names must be unique, but '" + this.s1l_1.j1(ix) + "' was repeated";
+                  throw IllegalArgumentException().u(toString(message_1));
+                }
+              }
+               while (inductionVariable_0 < ix);
+          }
+           while (!(element === last));
+      }
+      toString() {
+        return joinToString(this.s1l_1, ', ', 'MonthNames(', ')', VOID, VOID, String$toString$ref());
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof MonthNames()) {
+          tmp = equals(this.s1l_1, other.s1l_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.s1l_1);
+      }
+    }
+    initMetadataForClass($, 'MonthNames');
+    MonthNamesClass = $;
+  }
+  return MonthNamesClass;
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance_0 = this;
+        this.u1i_1 = new (DayOfWeekNames())(listOf(['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']));
+        this.v1i_1 = new (DayOfWeekNames())(listOf(['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']));
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_1() {
+  if (Companion_instance_0 === VOID)
+    new (Companion_0())();
+  return Companion_instance_0;
+}
+function String$toString$ref_0() {
+  var l = function (p0) {
+    return toString(p0);
+  };
+  l.callableName = 'toString';
+  return l;
+}
+var DayOfWeekNamesClass;
+function DayOfWeekNames() {
+  if (DayOfWeekNamesClass === VOID) {
+    class $ {
+      constructor(names) {
+        Companion_getInstance_1();
+        this.t1l_1 = names;
+        // Inline function 'kotlin.require' call
+        if (!(this.t1l_1.i1() === 7)) {
+          var message = 'Day of week names must contain exactly 7 elements';
+          throw IllegalArgumentException().u(toString(message));
+        }
+        // Inline function 'kotlin.collections.forEach' call
+        var progression = get_indices(this.t1l_1);
+        var inductionVariable = progression.u1_1;
+        var last = progression.v1_1;
+        if (inductionVariable <= last)
+          do {
+            var element = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var ix = element;
+            // Inline function 'kotlin.text.isNotEmpty' call
+            var this_0 = this.t1l_1.j1(ix);
+            // Inline function 'kotlin.require' call
+            if (!(charSequenceLength(this_0) > 0)) {
+              var message_0 = 'A day-of-week name can not be empty';
+              throw IllegalArgumentException().u(toString(message_0));
+            }
+            var inductionVariable_0 = 0;
+            if (inductionVariable_0 < ix)
+              do {
+                var ix2 = inductionVariable_0;
+                inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                // Inline function 'kotlin.require' call
+                if (!!(this.t1l_1.j1(ix) === this.t1l_1.j1(ix2))) {
+                  var message_1 = "Day-of-week names must be unique, but '" + this.t1l_1.j1(ix) + "' was repeated";
+                  throw IllegalArgumentException().u(toString(message_1));
+                }
+              }
+               while (inductionVariable_0 < ix);
+          }
+           while (!(element === last));
+      }
+      toString() {
+        return joinToString(this.t1l_1, ', ', 'DayOfWeekNames(', ')', VOID, VOID, String$toString$ref_0());
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof DayOfWeekNames()) {
+          tmp = equals(this.t1l_1, other.t1l_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.t1l_1);
+      }
+    }
+    initMetadataForClass($, 'DayOfWeekNames');
+    DayOfWeekNamesClass = $;
+  }
+  return DayOfWeekNamesClass;
+}
+var CompanionClass_1;
+function Companion_1() {
+  if (CompanionClass_1 === VOID) {
+    class $ {
+      u1l(block) {
+        var builder = new (Builder())(new (AppendableFormatStructure())());
+        block(builder);
+        return new (LocalDateFormat())(builder.z1i());
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass_1 = $;
+  }
+  return CompanionClass_1;
+}
+var Companion_instance_1;
+function Companion_getInstance_2() {
+  return Companion_instance_1;
+}
+var BuilderClass;
+function Builder() {
+  if (BuilderClass === VOID) {
+    class $ {
+      constructor(actualBuilder) {
+        this.v1l_1 = actualBuilder;
+      }
+      f1k() {
+        return this.v1l_1;
+      }
+      n1k(structure) {
+        return this.v1l_1.i1k(structure);
+      }
+      k1k() {
+        return new (Builder())(new (AppendableFormatStructure())());
+      }
+    }
+    protoOf($).l1k = appendAlternativeParsingImpl;
+    protoOf($).m1k = appendOptionalImpl;
+    protoOf($).t1i = chars;
+    protoOf($).z1i = build;
+    protoOf($).p1k = year;
+    protoOf($).s1i = year$default;
+    protoOf($).q1k = monthNumber;
+    protoOf($).r1k = monthNumber$default;
+    protoOf($).o1i = dayOfMonth;
+    protoOf($).s1k = dayOfMonth$default;
+    initMetadataForClass($, 'Builder', VOID, VOID, [AbstractDateTimeFormatBuilder(), AbstractWithDateBuilder()]);
+    BuilderClass = $;
+  }
+  return BuilderClass;
+}
+var LocalDateFormatClass;
+function LocalDateFormat() {
+  if (LocalDateFormatClass === VOID) {
+    class $ extends AbstractDateTimeFormat() {
+      constructor(actualFormat) {
+        super();
+        this.w1l_1 = actualFormat;
+      }
+      d1l() {
+        return this.w1l_1;
+      }
+      x1l(intermediate) {
+        return intermediate.u1j();
+      }
+      f1l(intermediate) {
+        return this.x1l(intermediate instanceof IncompleteLocalDate() ? intermediate : THROW_CCE());
+      }
+      g1l() {
+        return get_emptyIncompleteLocalDate();
+      }
+    }
+    initMetadataForClass($, 'LocalDateFormat');
+    LocalDateFormatClass = $;
+  }
+  return LocalDateFormatClass;
+}
+function requireParsedField(field, name) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  if (field == null) {
+    throw DateTimeFormatException().m1f('Can not create a ' + name + ' from the given input: the field ' + name + ' is missing');
+  }
+  return field;
+}
+function year(padding) {
+  return this.n1k(new (BasicFormatStructure())(new (YearDirective())(padding)));
+}
+function monthNumber(padding) {
+  return this.n1k(new (BasicFormatStructure())(new (MonthDirective())(padding)));
+}
+function monthName(names) {
+  return this.n1k(new (BasicFormatStructure())(new (MonthNameDirective())(names)));
+}
+function dayOfMonth(padding) {
+  return this.n1k(new (BasicFormatStructure())(new (DayDirective())(padding)));
+}
+function dayOfWeek(names) {
+  return this.n1k(new (BasicFormatStructure())(new (DayOfWeekDirective())(names)));
+}
+function date(format) {
+  var tmp;
+  if (format instanceof LocalDateFormat()) {
+    this.n1k(format.w1l_1);
+    tmp = Unit_instance;
+  }
+  return tmp;
+}
+var AbstractWithDateBuilderClass;
+function AbstractWithDateBuilder() {
+  if (AbstractWithDateBuilderClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'AbstractWithDateBuilder', VOID, VOID, [WithDate()]);
+    AbstractWithDateBuilderClass = $;
+  }
+  return AbstractWithDateBuilderClass;
+}
+var YearDirectiveClass;
+function YearDirective() {
+  if (YearDirectiveClass === VOID) {
+    class $ extends SignedIntFieldFormatDirective() {
+      constructor(padding, isYearOfEra) {
+        isYearOfEra = isYearOfEra === VOID ? false : isYearOfEra;
+        var tmp = DateFields_getInstance().y1l_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
+        super(tmp, tmp_0, null, padding.equals(Padding_SPACE_getInstance()) ? 4 : null, 4);
+        this.i1m_1 = padding;
+        this.j1m_1 = isYearOfEra;
+      }
+      equals(other) {
+        var tmp;
+        var tmp_0;
+        if (other instanceof YearDirective()) {
+          tmp_0 = this.i1m_1.equals(other.i1m_1);
+        } else {
+          tmp_0 = false;
+        }
+        if (tmp_0) {
+          tmp = this.j1m_1 === other.j1m_1;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return imul(this.i1m_1.hashCode(), 31) + getBooleanHashCode(this.j1m_1) | 0;
+      }
+    }
+    initMetadataForClass($, 'YearDirective');
+    YearDirectiveClass = $;
+  }
+  return YearDirectiveClass;
+}
+var MonthDirectiveClass;
+function MonthDirective() {
+  if (MonthDirectiveClass === VOID) {
+    class $ extends UnsignedIntFieldFormatDirective() {
+      constructor(padding) {
+        var tmp = DateFields_getInstance().z1l_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
+        super(tmp, tmp_0, padding.equals(Padding_SPACE_getInstance()) ? 2 : null);
+        this.v1m_1 = padding;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof MonthDirective()) {
+          tmp = this.v1m_1.equals(other.v1m_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.v1m_1.hashCode();
+      }
+    }
+    initMetadataForClass($, 'MonthDirective');
+    MonthDirectiveClass = $;
+  }
+  return MonthDirectiveClass;
+}
+var MonthNameDirectiveClass;
+function MonthNameDirective() {
+  if (MonthNameDirectiveClass === VOID) {
+    class $ extends NamedUnsignedIntFieldFormatDirective() {
+      constructor(names) {
+        super(DateFields_getInstance().z1l_1, names.s1l_1, 'monthName');
+        this.d1n_1 = names;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof MonthNameDirective()) {
+          tmp = equals(this.d1n_1.s1l_1, other.d1n_1.s1l_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.d1n_1.s1l_1);
+      }
+    }
+    initMetadataForClass($, 'MonthNameDirective');
+    MonthNameDirectiveClass = $;
+  }
+  return MonthNameDirectiveClass;
+}
+var DayDirectiveClass;
+function DayDirective() {
+  if (DayDirectiveClass === VOID) {
+    class $ extends UnsignedIntFieldFormatDirective() {
+      constructor(padding) {
+        var tmp = DateFields_getInstance().a1m_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
+        super(tmp, tmp_0, padding.equals(Padding_SPACE_getInstance()) ? 2 : null);
+        this.l1n_1 = padding;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof DayDirective()) {
+          tmp = this.l1n_1.equals(other.l1n_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.l1n_1.hashCode();
+      }
+    }
+    initMetadataForClass($, 'DayDirective');
+    DayDirectiveClass = $;
+  }
+  return DayDirectiveClass;
+}
+var DayOfWeekDirectiveClass;
+function DayOfWeekDirective() {
+  if (DayOfWeekDirectiveClass === VOID) {
+    class $ extends NamedUnsignedIntFieldFormatDirective() {
+      constructor(names) {
+        super(DateFields_getInstance().b1m_1, names.t1l_1, 'dayOfWeekName');
+        this.p1n_1 = names;
+      }
+      equals(other) {
+        var tmp;
+        if (other instanceof DayOfWeekDirective()) {
+          tmp = equals(this.p1n_1.t1l_1, other.p1n_1.t1l_1);
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.p1n_1.t1l_1);
+      }
+    }
+    initMetadataForClass($, 'DayOfWeekDirective');
+    DayOfWeekDirectiveClass = $;
+  }
+  return DayOfWeekDirectiveClass;
+}
+function DateFieldContainer$_get_year_$ref_fy14wc() {
+  return function (p0) {
+    return p0.z1g();
+  };
+}
+function DateFieldContainer$_set_year_$ref_sqxgd4() {
+  return function (p0, p1) {
+    p0.y1g(p1);
+    return Unit_instance;
+  };
+}
+function DateFieldContainer$_get_monthNumber_$ref_c94z1k() {
+  return function (p0) {
+    return p0.x1g();
+  };
+}
+function DateFieldContainer$_set_monthNumber_$ref_25erj0() {
+  return function (p0, p1) {
+    p0.w1g(p1);
+    return Unit_instance;
+  };
+}
+function DateFieldContainer$_get_dayOfMonth_$ref_c8x4t8() {
+  return function (p0) {
+    return p0.r1g();
+  };
+}
+function DateFieldContainer$_set_dayOfMonth_$ref_da6b88() {
+  return function (p0, p1) {
+    p0.l1g(p1);
+    return Unit_instance;
+  };
+}
+function DateFieldContainer$_get_isoDayOfWeek_$ref_amcy49() {
+  return function (p0) {
+    return p0.v1g();
+  };
+}
+function DateFieldContainer$_set_isoDayOfWeek_$ref_vbmus3() {
+  return function (p0, p1) {
+    p0.u1g(p1);
+    return Unit_instance;
+  };
+}
+function DateFieldContainer$_get_dayOfYear_$ref_2m6gfz() {
+  return function (p0) {
+    return p0.t1g();
+  };
+}
+function DateFieldContainer$_set_dayOfYear_$ref_cll22d() {
+  return function (p0, p1) {
+    p0.s1g(p1);
+    return Unit_instance;
+  };
+}
+var DateFieldsClass;
+function DateFields() {
+  if (DateFieldsClass === VOID) {
+    class $ {
+      constructor() {
+        DateFields_instance = this;
+        var tmp = this;
+        var tmp_0 = KMutableProperty1();
+        var tmp_1 = DateFieldContainer$_get_year_$ref_fy14wc();
+        tmp.y1l_1 = new (GenericFieldSpec())(new (PropertyAccessor())(getPropertyCallableRef('year', 1, tmp_0, tmp_1, DateFieldContainer$_set_year_$ref_sqxgd4())));
+        var tmp_2 = this;
+        var tmp_3 = KMutableProperty1();
+        var tmp_4 = DateFieldContainer$_get_monthNumber_$ref_c94z1k();
+        tmp_2.z1l_1 = new (UnsignedFieldSpec())(new (PropertyAccessor())(getPropertyCallableRef('monthNumber', 1, tmp_3, tmp_4, DateFieldContainer$_set_monthNumber_$ref_25erj0())), 1, 12);
+        var tmp_5 = this;
+        var tmp_6 = KMutableProperty1();
+        var tmp_7 = DateFieldContainer$_get_dayOfMonth_$ref_c8x4t8();
+        tmp_5.a1m_1 = new (UnsignedFieldSpec())(new (PropertyAccessor())(getPropertyCallableRef('dayOfMonth', 1, tmp_6, tmp_7, DateFieldContainer$_set_dayOfMonth_$ref_da6b88())), 1, 31);
+        var tmp_8 = this;
+        var tmp_9 = KMutableProperty1();
+        var tmp_10 = DateFieldContainer$_get_isoDayOfWeek_$ref_amcy49();
+        tmp_8.b1m_1 = new (UnsignedFieldSpec())(new (PropertyAccessor())(getPropertyCallableRef('isoDayOfWeek', 1, tmp_9, tmp_10, DateFieldContainer$_set_isoDayOfWeek_$ref_vbmus3())), 1, 7);
+        var tmp_11 = this;
+        var tmp_12 = KMutableProperty1();
+        var tmp_13 = DateFieldContainer$_get_dayOfYear_$ref_2m6gfz();
+        tmp_11.c1m_1 = new (UnsignedFieldSpec())(new (PropertyAccessor())(getPropertyCallableRef('dayOfYear', 1, tmp_12, tmp_13, DateFieldContainer$_set_dayOfYear_$ref_cll22d())), 1, 366);
+      }
+    }
+    initMetadataForObject($, 'DateFields');
+    DateFieldsClass = $;
+  }
+  return DateFieldsClass;
+}
+var DateFields_instance;
+function DateFields_getInstance() {
+  if (DateFields_instance === VOID)
+    new (DateFields())();
+  return DateFields_instance;
+}
+function ISO_DATE$delegate$lambda() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp = Companion_instance_1;
+  return tmp.u1l(ISO_DATE$delegate$lambda$lambda);
+}
+function ISO_DATE$delegate$lambda$lambda($this$build) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  $this$build.s1i();
+  char($this$build, _Char___init__impl__6a9atx(45));
+  $this$build.r1k();
+  char($this$build, _Char___init__impl__6a9atx(45));
+  $this$build.s1k();
+  return Unit_instance;
+}
+function _get_ISO_DATE_$ref_powsum() {
+  return function () {
+    return get_ISO_DATE();
+  };
+}
+function ISO_DATE_BASIC$delegate$lambda() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp = Companion_instance_1;
+  return tmp.u1l(ISO_DATE_BASIC$delegate$lambda$lambda);
+}
+function ISO_DATE_BASIC$delegate$lambda$lambda($this$build) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  $this$build.s1i();
+  $this$build.r1k();
+  $this$build.s1k();
+  return Unit_instance;
+}
+function _get_ISO_DATE_BASIC_$ref_3fs8eb() {
+  return function () {
+    return get_ISO_DATE_BASIC();
+  };
+}
+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())();
+  }
+}
+//region block: init
+Companion_instance_1 = new (Companion_1())();
+//endregion
+//region block: exports
+export {
+  Companion_getInstance_1 as Companion_getInstanceem9vodzsunmv,
+  Companion_getInstance_0 as Companion_getInstance2euvj2567gjrn,
+  date as date3ki45iw426xr8,
+  dayOfMonth as dayOfMonths8rfgqv9djoz,
+  dayOfWeek as dayOfWeek16trujebvwhwq,
+  monthName as monthNames1ujl7xt4e7x,
+  monthNumber as monthNumber39ajqip9c32rn,
+  year as year2o42o5s31g3p8,
+  AbstractWithDateBuilder as AbstractWithDateBuilder1xwo9aqwqe32f,
+  get_ISO_DATE as get_ISO_DATE1ah0stqy13618,
+  get_ISO_DATE_BASIC as get_ISO_DATE_BASIC1k4wiybcckf8,
+  IncompleteLocalDate as IncompleteLocalDate2wlnrm8wqbjky,
+  requireParsedField as requireParsedField387b2jr94jy2p,
+};
+//endregion
+
+//# sourceMappingURL=LocalDateFormat.mjs.map