@attocash/commons-test 6.0.0

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

@@ -0,0 +1,332 @@
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  fromInt2ii0rejb1w62w as fromInt,
+  modulooi4g1kq3dmtt as modulo,
+  dividelr0uqtdj497z as divide,
+  convertToInty04h231mmjoh as convertToInt,
+  shiftRight2gqph14wydb8s as shiftRight,
+} from '../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.mjs';
+import {
+  safeMultiply1xb0xo3cufzd3 as safeMultiply,
+  safeMultiplyomi65rg5l1en as safeMultiply_0,
+} from './internal/mathNative.mjs';
+import {
+  TimeBasedDateTimeUnitSerializer_getInstancewuqoobna26f2 as TimeBasedDateTimeUnitSerializer_getInstance,
+  DateBasedDateTimeUnitSerializer_getInstance2rikesu6oglqz as DateBasedDateTimeUnitSerializer_getInstance,
+  DayBasedDateTimeUnitSerializer_getInstance23o8q93ovx0p5 as DayBasedDateTimeUnitSerializer_getInstance,
+  MonthBasedDateTimeUnitSerializer_getInstancecpechj7jc0xd as MonthBasedDateTimeUnitSerializer_getInstance,
+  DateTimeUnitSerializer_getInstance3b5n2mvis6ri5 as DateTimeUnitSerializer_getInstance,
+} from './serializers/DateTimeUnitSerializers.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
+var CompanionClass_1;
+function Companion_1() {
+  if (CompanionClass_1 === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass_1 = $;
+  }
+  return CompanionClass_1;
+}
+var Companion_instance_1;
+function Companion_getInstance_1() {
+  return Companion_instance_1;
+}
+var CompanionClass_2;
+function Companion_2() {
+  if (CompanionClass_2 === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass_2 = $;
+  }
+  return CompanionClass_2;
+}
+var Companion_instance_2;
+function Companion_getInstance_2() {
+  return Companion_instance_2;
+}
+var TimeBasedClass;
+function TimeBased() {
+  if (TimeBasedClass === VOID) {
+    class $ extends DateTimeUnit() {
+      constructor(nanoseconds) {
+        super();
+        this.c40_1 = nanoseconds;
+        // Inline function 'kotlin.require' call
+        if (!(this.c40_1 > 0n)) {
+          var message = 'Unit duration must be positive, but was ' + this.c40_1.toString() + ' ns.';
+          throw IllegalArgumentException().i1(toString(message));
+        }
+        if (modulo(this.c40_1, 3600000000000n) === 0n) {
+          this.d40_1 = 'HOUR';
+          this.e40_1 = divide(this.c40_1, 3600000000000n);
+        } else {
+          if (modulo(this.c40_1, 60000000000n) === 0n) {
+            this.d40_1 = 'MINUTE';
+            this.e40_1 = divide(this.c40_1, 60000000000n);
+          } else {
+            var tmp0 = this.c40_1;
+            // Inline function 'kotlin.Long.rem' call
+            var other = 1000000000;
+            if (modulo(tmp0, fromInt(other)) === 0n) {
+              this.d40_1 = 'SECOND';
+              var tmp = this;
+              var tmp0_0 = this.c40_1;
+              // Inline function 'kotlin.Long.div' call
+              var other_0 = 1000000000;
+              tmp.e40_1 = divide(tmp0_0, fromInt(other_0));
+            } else {
+              // Inline function 'kotlin.Long.rem' call
+              var this_0 = this.c40_1;
+              if (modulo(this_0, fromInt(1000000)) === 0n) {
+                this.d40_1 = 'MILLISECOND';
+                var tmp_0 = this;
+                // Inline function 'kotlin.Long.div' call
+                var this_1 = this.c40_1;
+                tmp_0.e40_1 = divide(this_1, fromInt(1000000));
+              } else {
+                // Inline function 'kotlin.Long.rem' call
+                var this_2 = this.c40_1;
+                if (modulo(this_2, fromInt(1000)) === 0n) {
+                  this.d40_1 = 'MICROSECOND';
+                  var tmp_1 = this;
+                  // Inline function 'kotlin.Long.div' call
+                  var this_3 = this.c40_1;
+                  tmp_1.e40_1 = divide(this_3, fromInt(1000));
+                } else {
+                  this.d40_1 = 'NANOSECOND';
+                  this.e40_1 = this.c40_1;
+                }
+              }
+            }
+          }
+        }
+      }
+      f40(scalar) {
+        return new (TimeBased())(safeMultiply(this.c40_1, fromInt(scalar)));
+      }
+      equals(other) {
+        var tmp;
+        if (this === other) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          if (other instanceof TimeBased()) {
+            tmp_0 = this.c40_1 === other.c40_1;
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return convertToInt(this.c40_1) ^ convertToInt(shiftRight(this.c40_1, 32));
+      }
+      toString() {
+        return this.g40(this.e40_1, this.d40_1);
+      }
+    }
+    initMetadataForClass($, 'TimeBased', VOID, VOID, VOID, VOID, VOID, {0: TimeBasedDateTimeUnitSerializer_getInstance});
+    TimeBasedClass = $;
+  }
+  return TimeBasedClass;
+}
+var DateBasedClass;
+function DateBased() {
+  if (DateBasedClass === VOID) {
+    class $ extends DateTimeUnit() {}
+    initMetadataForClass($, 'DateBased', VOID, VOID, VOID, VOID, VOID, {0: DateBasedDateTimeUnitSerializer_getInstance});
+    DateBasedClass = $;
+  }
+  return DateBasedClass;
+}
+var DayBasedClass;
+function DayBased() {
+  if (DayBasedClass === VOID) {
+    class $ extends DateBased() {
+      constructor(days) {
+        super();
+        this.i40_1 = days;
+        // Inline function 'kotlin.require' call
+        if (!(this.i40_1 > 0)) {
+          var message = 'Unit duration must be positive, but was ' + this.i40_1 + ' days.';
+          throw IllegalArgumentException().i1(toString(message));
+        }
+      }
+      f40(scalar) {
+        return new (DayBased())(safeMultiply_0(this.i40_1, scalar));
+      }
+      equals(other) {
+        var tmp;
+        if (this === other) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          if (other instanceof DayBased()) {
+            tmp_0 = this.i40_1 === other.i40_1;
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.i40_1 ^ 65536;
+      }
+      toString() {
+        return (this.i40_1 % 7 | 0) === 0 ? this.h40(this.i40_1 / 7 | 0, 'WEEK') : this.h40(this.i40_1, 'DAY');
+      }
+    }
+    initMetadataForClass($, 'DayBased', VOID, VOID, VOID, VOID, VOID, {0: DayBasedDateTimeUnitSerializer_getInstance});
+    DayBasedClass = $;
+  }
+  return DayBasedClass;
+}
+var MonthBasedClass;
+function MonthBased() {
+  if (MonthBasedClass === VOID) {
+    class $ extends DateBased() {
+      constructor(months) {
+        super();
+        this.j40_1 = months;
+        // Inline function 'kotlin.require' call
+        if (!(this.j40_1 > 0)) {
+          var message = 'Unit duration must be positive, but was ' + this.j40_1 + ' months.';
+          throw IllegalArgumentException().i1(toString(message));
+        }
+      }
+      f40(scalar) {
+        return new (MonthBased())(safeMultiply_0(this.j40_1, scalar));
+      }
+      equals(other) {
+        var tmp;
+        if (this === other) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          if (other instanceof MonthBased()) {
+            tmp_0 = this.j40_1 === other.j40_1;
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.j40_1 ^ 131072;
+      }
+      toString() {
+        return (this.j40_1 % 1200 | 0) === 0 ? this.h40(this.j40_1 / 1200 | 0, 'CENTURY') : (this.j40_1 % 12 | 0) === 0 ? this.h40(this.j40_1 / 12 | 0, 'YEAR') : (this.j40_1 % 3 | 0) === 0 ? this.h40(this.j40_1 / 3 | 0, 'QUARTER') : this.h40(this.j40_1, 'MONTH');
+      }
+    }
+    initMetadataForClass($, 'MonthBased', VOID, VOID, VOID, VOID, VOID, {0: MonthBasedDateTimeUnitSerializer_getInstance});
+    MonthBasedClass = $;
+  }
+  return MonthBasedClass;
+}
+var CompanionClass_3;
+function Companion_3() {
+  if (CompanionClass_3 === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance_3 = this;
+        this.k40_1 = new (TimeBased())(1n);
+        this.l40_1 = this.k40_1.f40(1000);
+        this.m40_1 = this.l40_1.f40(1000);
+        this.n40_1 = this.m40_1.f40(1000);
+        this.o40_1 = this.n40_1.f40(60);
+        this.p40_1 = this.o40_1.f40(60);
+        this.q40_1 = new (DayBased())(1);
+        this.r40_1 = this.q40_1.f40(7);
+        this.s40_1 = new (MonthBased())(1);
+        this.t40_1 = this.s40_1.f40(3);
+        this.u40_1 = this.s40_1.f40(12);
+        this.v40_1 = this.u40_1.f40(100);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass_3 = $;
+  }
+  return CompanionClass_3;
+}
+var Companion_instance_3;
+function Companion_getInstance_3() {
+  if (Companion_instance_3 === VOID)
+    new (Companion_3())();
+  return Companion_instance_3;
+}
+var DateTimeUnitClass;
+function DateTimeUnit() {
+  if (DateTimeUnitClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_getInstance_3();
+      }
+      h40(value, unit) {
+        return value === 1 ? unit : '' + value + '-' + unit;
+      }
+      g40(value, unit) {
+        return value === 1n ? unit : value.toString() + '-' + unit;
+      }
+    }
+    initMetadataForClass($, 'DateTimeUnit', VOID, VOID, VOID, VOID, VOID, {0: DateTimeUnitSerializer_getInstance});
+    DateTimeUnitClass = $;
+  }
+  return DateTimeUnitClass;
+}
+//region block: init
+Companion_instance = new (Companion())();
+Companion_instance_0 = new (Companion_0())();
+Companion_instance_1 = new (Companion_1())();
+Companion_instance_2 = new (Companion_2())();
+//endregion
+//region block: exports
+export {
+  Companion_getInstance_3 as Companion_getInstance1hjnoi8x2xjhl,
+  DateBased as DateBasedu1hioe8kvjhw,
+  DayBased as DayBased28hvf1xjg5r93,
+  MonthBased as MonthBased16lxw4e6nhntg,
+  TimeBased as TimeBasedn2y4mla0fo0k,
+  DateTimeUnit as DateTimeUnit3ugctnw90699o,
+};
+//endregion
+
+//# sourceMappingURL=DateTimeUnit.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../opt/buildAgent/work/8ebe0a8279b7bad8/core/common/src/DateTimeUnit.kt","src/kotlin/util/Preconditions.kt","js/builtins/Primitives.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["nanoseconds","message","times","scalar","equals","other","hashCode","toString","days","months","formatToString","value","unit"],"mappings":"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"}

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

@@ -0,0 +1,96 @@
+import { enumEntries20mr21zbe3az4 as enumEntries } from '../../../kotlin-kotlin-stdlib/kotlin/enums/EnumEntries.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_isoDayNumber(_this__u8e3s4) {
+  return _this__u8e3s4.v3_1 + 1 | 0;
+}
+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())('MONDAY', 0);
+  DayOfWeek_TUESDAY_instance = new (DayOfWeek())('TUESDAY', 1);
+  DayOfWeek_WEDNESDAY_instance = new (DayOfWeek())('WEDNESDAY', 2);
+  DayOfWeek_THURSDAY_instance = new (DayOfWeek())('THURSDAY', 3);
+  DayOfWeek_FRIDAY_instance = new (DayOfWeek())('FRIDAY', 4);
+  DayOfWeek_SATURDAY_instance = new (DayOfWeek())('SATURDAY', 5);
+  DayOfWeek_SUNDAY_instance = new (DayOfWeek())('SUNDAY', 6);
+}
+var $ENTRIES;
+var DayOfWeekClass;
+function DayOfWeek() {
+  if (DayOfWeekClass === VOID) {
+    class $ extends Enum() {}
+    initMetadataForClass($, 'DayOfWeek');
+    DayOfWeekClass = $;
+  }
+  return DayOfWeekClass;
+}
+function DayOfWeek_0(isoDayNumber) {
+  // Inline function 'kotlin.require' call
+  if (!(1 <= isoDayNumber ? isoDayNumber <= 7 : false)) {
+    var message = 'Expected ISO day-of-week number in 1..7, got ' + isoDayNumber;
+    throw IllegalArgumentException().i1(toString(message));
+  }
+  return get_entries().o1(isoDayNumber - 1 | 0);
+}
+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;
+}
+//region block: exports
+export {
+  DayOfWeek_0 as DayOfWeek2xlo40o03f5e,
+  get_isoDayNumber as get_isoDayNumberrycq4er3aoh9,
+};
+//endregion
+
+//# sourceMappingURL=DayOfWeek.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../opt/buildAgent/work/8ebe0a8279b7bad8/core/common/src/DayOfWeek.kt","src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-isoDayNumber>","<this>","values","<get-entries>","DayOfWeek","isoDayNumber","message"],"mappings":";;;;;;;;;;;yBAmCuCA,CAA5BC,aAA4BD,EAAQ;A,EAAW,OAAX,qBAAU,CAAC,I;AAAD,C;;;;;;;;eAfzDE,CAAAA,E;;C;oBAAAC,CAAAA,E;;;;C;;;;;;gDApBA,Q,EAAA,C;iDAAA,S,EAAA,C;mDAAA,W,EAAA,C;kDAAA,U,EAAA,C;gDAAA,Q,EAAA,C;kDAAA,U,EAAA,C;gDAAA,Q,EAAA,C;;;;;;;;;;;;oBA2CAC,CAAqBC,YAArBD,EAAmD;A;ECR3C,MDSoB,CAAhB,mCAAmB,CAAnB,QCTJ,E,CAAQ;A,QACRE,UDQ6B,+CAAD,GAA+C,Y;ICP3E,oCAAuC,SAAR,OAAQ,CAAvC,C;EACJ,C;EDOA,OAAiB,aAAV,IAAkB,eAAe,CAAjC,K;AACX,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,104 @@
+import { captureStack1fzi4aczwc4hg as captureStack } from '../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  RuntimeException1r3t0zl97011n as RuntimeException,
+} from '../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function init_kotlinx_datetime_DateTimeFormatException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.z40_1);
+}
+var DateTimeFormatExceptionClass;
+function DateTimeFormatException() {
+  if (DateTimeFormatExceptionClass === VOID) {
+    class $ extends IllegalArgumentException() {
+      static a41() {
+        var $this = this.jd();
+        init_kotlinx_datetime_DateTimeFormatException($this);
+        return $this;
+      }
+      static b41(message) {
+        var $this = this.i1(message);
+        init_kotlinx_datetime_DateTimeFormatException($this);
+        return $this;
+      }
+      static c41(message, cause) {
+        var $this = this.kd(message, cause);
+        init_kotlinx_datetime_DateTimeFormatException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'DateTimeFormatException', $.a41);
+    DateTimeFormatExceptionClass = $;
+  }
+  return DateTimeFormatExceptionClass;
+}
+function init_kotlinx_datetime_IllegalTimeZoneException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.g41_1);
+}
+var IllegalTimeZoneExceptionClass;
+function IllegalTimeZoneException() {
+  if (IllegalTimeZoneExceptionClass === VOID) {
+    class $ extends IllegalArgumentException() {
+      static h41() {
+        var $this = this.jd();
+        init_kotlinx_datetime_IllegalTimeZoneException($this);
+        return $this;
+      }
+      static i41(message) {
+        var $this = this.i1(message);
+        init_kotlinx_datetime_IllegalTimeZoneException($this);
+        return $this;
+      }
+      static j41(cause) {
+        var $this = this.md(cause);
+        init_kotlinx_datetime_IllegalTimeZoneException($this);
+        return $this;
+      }
+      static k41(message, cause) {
+        var $this = this.kd(message, cause);
+        init_kotlinx_datetime_IllegalTimeZoneException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'IllegalTimeZoneException', $.h41);
+    IllegalTimeZoneExceptionClass = $;
+  }
+  return IllegalTimeZoneExceptionClass;
+}
+function init_kotlinx_datetime_DateTimeArithmeticException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.n41_1);
+}
+var DateTimeArithmeticExceptionClass;
+function DateTimeArithmeticException() {
+  if (DateTimeArithmeticExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static o41() {
+        var $this = this.p2();
+        init_kotlinx_datetime_DateTimeArithmeticException($this);
+        return $this;
+      }
+      static p41(message, cause) {
+        var $this = this.ld(message, cause);
+        init_kotlinx_datetime_DateTimeArithmeticException($this);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'DateTimeArithmeticException', $.o41);
+    DateTimeArithmeticExceptionClass = $;
+  }
+  return DateTimeArithmeticExceptionClass;
+}
+//region block: exports
+export {
+  DateTimeArithmeticException as DateTimeArithmeticException3b9ehoczpp1e2,
+  DateTimeFormatException as DateTimeFormatException2onfeknbywaob,
+  IllegalTimeZoneException as IllegalTimeZoneException2q01rvpc2etsw,
+};
+//endregion
+
+//# sourceMappingURL=Exceptions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../opt/buildAgent/work/8ebe0a8279b7bad8/core/common/src/Exceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["message","cause"],"mappings":";;;;;;;;;;;uDA2BA,a,EAAA;A;AAKA,C;;;;;;;;;;iBAHgBA,O;4BAAwB,O;;;;iBAExBA,O,EAAiBC,K;4BAAyB,O,EAAS,K;;;;;;;;;;wDAXnE,a,EAAA;A;AAKA,C;;;;;;;;;;iBAHuBD,O;4BAAwB,O;;;;iBACxBC,K;4BAAyB,K;;;;iBACzBD,O,EAAiBC,K;4BAAyB,O,EAAS,K;;;;;;;;;;2DAd1E,a,EAAA;A;AAKA,C;;;;;;;;;;iBADuBD,O,EAAiBC,K;4BAAyB,O,EAAS,K;;;;;;;;;;;;;;"}