@attocash/commons-js 5.4.1 → 6.1.0

package/kotlin-kotlin-stdlib/kotlin/time/Instant.mjs

@@ -0,0 +1,953 @@
+import {
+  dividelr0uqtdj497z as divide,
+  subtract2orl8z9upxd9l as subtract,
+  multiply2k9eolhnz1bjv as multiply,
+  modulooi4g1kq3dmtt as modulo,
+  negate13xrbakfwasjy as negate,
+  shiftRight2gqph14wydb8s as shiftRight,
+  add2suhfggl4zvkk as add,
+  fromInt2ii0rejb1w62w as fromInt,
+  convertToInty04h231mmjoh as convertToInt,
+  numberToLong2pakxeg38estk as numberToLong,
+} from '../js/internal/longAsBigInt/longAsBigInt.mjs';
+import { get_ONEazvfdh9ju3d4 as get_ONE } from '../js/internal/boxedLong/boxedLong.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  getBigIntHashCode294hi5bdhtj6e as getBigIntHashCode,
+  captureStack1fzi4aczwc4hg as captureStack,
+  equals2au1ep9vhcato as equals,
+} from '../js/coreRuntime.mjs';
+import {
+  _Duration___get_inWholeSeconds__impl__hpy7b32fu0rnoit26fw as _Duration___get_inWholeSeconds__impl__hpy7b3,
+  _Duration___get_nanosecondsComponent__impl__nh19kq1udaeb2ce31e1 as _Duration___get_nanosecondsComponent__impl__nh19kq,
+  Duration__isPositive_impl_tvkkt22mscvvkiz7i1u as Duration__isPositive_impl_tvkkt2,
+  Duration__unaryMinus_impl_x2k1y03dvxfmeyyyudl as Duration__unaryMinus_impl_x2k1y0,
+  Companion_getInstance3vz87v4c01z2t as Companion_getInstance,
+  toDurationba1nlt78o6vu as toDuration,
+  toDuration7gy6v749ektt as toDuration_0,
+  Duration__plus_impl_yu9v8f2gb5hwgakp0dd as Duration__plus_impl_yu9v8f,
+} from './Duration.mjs';
+import {
+  DurationUnit_SECONDS_getInstance3jias9ne5z4er as DurationUnit_SECONDS_getInstance,
+  DurationUnit_NANOSECONDS_getInstancexzp0zqz7eqak as DurationUnit_NANOSECONDS_getInstance,
+} from './DurationUnitJs.mjs';
+import { compareTo3ankvs086tmwq as compareTo } from '../js/compareTo.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../hacks.mjs';
+import { Comparable198qfk8pnblz0 as Comparable } from '../Comparable.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../text/StringBuilderJs.mjs';
+import { abs1kdzbjes1idip as abs } from '../math/math.mjs';
+import {
+  _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx,
+  Char__minus_impl_a2frrh3548ixwefqxih as Char__minus_impl_a2frrh,
+  Char__compareTo_impl_ypi4mbdrkik40uwhqc as Char__compareTo_impl_ypi4mb,
+  toString3o7ifthqydp6e as toString_0,
+  Char19o2r8palgjof as Char,
+} from '../Char.mjs';
+import { substring3saq8ornu0luv as substring } from '../text/stringJs.mjs';
+import {
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+} from '../js/charSequenceJs.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function get_POWERS_OF_TEN() {
+  _init_properties_Instant_kt__2myitt();
+  return POWERS_OF_TEN;
+}
+var POWERS_OF_TEN;
+function get_asciiDigitPositionsInIsoStringAfterYear() {
+  _init_properties_Instant_kt__2myitt();
+  return asciiDigitPositionsInIsoStringAfterYear;
+}
+var asciiDigitPositionsInIsoStringAfterYear;
+function get_colonsInIsoOffsetString() {
+  _init_properties_Instant_kt__2myitt();
+  return colonsInIsoOffsetString;
+}
+var colonsInIsoOffsetString;
+function get_asciiDigitsInIsoOffsetString() {
+  _init_properties_Instant_kt__2myitt();
+  return asciiDigitsInIsoOffsetString;
+}
+var asciiDigitsInIsoOffsetString;
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.ci_1 = new (Instant())(-31557014167219200n, 0);
+        this.di_1 = new (Instant())(31556889864403199n, 999999999);
+      }
+      ei(epochMilliseconds) {
+        // Inline function 'kotlin.floorDiv' call
+        var q = divide(epochMilliseconds, 1000n);
+        if ((epochMilliseconds ^ 1000n) < 0n && !(multiply(q, 1000n) === epochMilliseconds)) {
+          var _unary__edvuaz = q;
+          q = subtract(_unary__edvuaz, get_ONE());
+        }
+        var epochSeconds = q;
+        // Inline function 'kotlin.mod' call
+        var r = modulo(epochMilliseconds, 1000n);
+        // Inline function 'kotlin.Long.times' call
+        var this_0 = add(r, 1000n & shiftRight((r ^ 1000n) & (r | negate(r)), 63));
+        var tmp$ret$2 = multiply(this_0, fromInt(1000000));
+        var nanosecondsOfSecond = convertToInt(tmp$ret$2);
+        return epochSeconds < -31557014167219200n ? this.ci_1 : epochSeconds > 31556889864403199n ? this.di_1 : this.bp(epochSeconds, nanosecondsOfSecond);
+      }
+      cp(epochSeconds, nanosecondAdjustment) {
+        // Inline function 'kotlin.floorDiv' call
+        var other = 1000000000n;
+        var q = divide(nanosecondAdjustment, other);
+        if ((nanosecondAdjustment ^ other) < 0n && !(multiply(q, other) === nanosecondAdjustment)) {
+          var _unary__edvuaz = q;
+          q = subtract(_unary__edvuaz, get_ONE());
+        }
+        // Inline function 'kotlin.time.safeAddOrElse' call
+        var b = q;
+        var sum = add(epochSeconds, b);
+        if ((epochSeconds ^ sum) < 0n && (epochSeconds ^ b) >= 0n) {
+          return epochSeconds > 0n ? Companion_getInstance_0().di_1 : Companion_getInstance_0().ci_1;
+        }
+        var seconds = sum;
+        var tmp;
+        if (seconds < -31557014167219200n) {
+          tmp = this.ci_1;
+        } else if (seconds > 31556889864403199n) {
+          tmp = this.di_1;
+        } else {
+          // Inline function 'kotlin.mod' call
+          var other_0 = 1000000000n;
+          var r = modulo(nanosecondAdjustment, other_0);
+          var tmp$ret$2 = add(r, other_0 & shiftRight((r ^ other_0) & (r | negate(r)), 63));
+          var nanoseconds = convertToInt(tmp$ret$2);
+          tmp = new (Instant())(seconds, nanoseconds);
+        }
+        return tmp;
+      }
+      dp(epochSeconds, nanosecondAdjustment, $super) {
+        nanosecondAdjustment = nanosecondAdjustment === VOID ? 0n : nanosecondAdjustment;
+        return $super === VOID ? this.cp(epochSeconds, nanosecondAdjustment) : $super.cp.call(this, epochSeconds, nanosecondAdjustment);
+      }
+      bp(epochSeconds, nanosecondAdjustment) {
+        return this.cp(epochSeconds, fromInt(nanosecondAdjustment));
+      }
+      ep(input) {
+        return parseIso(input).fp();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var InstantClass;
+function Instant() {
+  if (InstantClass === VOID) {
+    class $ {
+      constructor(epochSeconds, nanosecondsOfSecond) {
+        Companion_getInstance_0();
+        this.gp_1 = epochSeconds;
+        this.hp_1 = nanosecondsOfSecond;
+        var containsArg = this.gp_1;
+        // Inline function 'kotlin.require' call
+        if (!(-31557014167219200n <= containsArg ? containsArg <= 31556889864403199n : false)) {
+          var message = 'Instant exceeds minimum or maximum instant';
+          throw IllegalArgumentException().j1(toString(message));
+        }
+      }
+      ip() {
+        if (this.gp_1 >= 0n) {
+          var tmp0 = this.gp_1;
+          var tmp$ret$0;
+          $l$block_1: {
+            // Inline function 'kotlin.time.safeMultiplyOrElse' call
+            if (1000n === 1n) {
+              tmp$ret$0 = tmp0;
+              break $l$block_1;
+            }
+            if (tmp0 === 1n) {
+              tmp$ret$0 = 1000n;
+              break $l$block_1;
+            }
+            if (tmp0 === 0n || 1000n === 0n) {
+              tmp$ret$0 = 0n;
+              break $l$block_1;
+            }
+            var total = multiply(tmp0, 1000n);
+            if (!(divide(total, 1000n) === tmp0) || (tmp0 === -9223372036854775808n && 1000n === -1n) || (1000n === -9223372036854775808n && tmp0 === -1n)) {
+              return 9223372036854775807n;
+            }
+            tmp$ret$0 = total;
+          }
+          var millis = tmp$ret$0;
+          // Inline function 'kotlin.time.safeAddOrElse' call
+          var b = fromInt(this.hp_1 / 1000000 | 0);
+          var sum = add(millis, b);
+          if ((millis ^ sum) < 0n && (millis ^ b) >= 0n) {
+            return 9223372036854775807n;
+          }
+          return sum;
+        } else {
+          // Inline function 'kotlin.Long.plus' call
+          var this_0 = this.gp_1;
+          var tmp0_0 = add(this_0, fromInt(1));
+          var tmp$ret$3;
+          $l$block_4: {
+            // Inline function 'kotlin.time.safeMultiplyOrElse' call
+            if (1000n === 1n) {
+              tmp$ret$3 = tmp0_0;
+              break $l$block_4;
+            }
+            if (tmp0_0 === 1n) {
+              tmp$ret$3 = 1000n;
+              break $l$block_4;
+            }
+            if (tmp0_0 === 0n || 1000n === 0n) {
+              tmp$ret$3 = 0n;
+              break $l$block_4;
+            }
+            var total_0 = multiply(tmp0_0, 1000n);
+            if (!(divide(total_0, 1000n) === tmp0_0) || (tmp0_0 === -9223372036854775808n && 1000n === -1n) || (1000n === -9223372036854775808n && tmp0_0 === -1n)) {
+              return -9223372036854775808n;
+            }
+            tmp$ret$3 = total_0;
+          }
+          var millis_0 = tmp$ret$3;
+          // Inline function 'kotlin.time.safeAddOrElse' call
+          var b_0 = fromInt((this.hp_1 / 1000000 | 0) - 1000 | 0);
+          var sum_0 = add(millis_0, b_0);
+          if ((millis_0 ^ sum_0) < 0n && (millis_0 ^ b_0) >= 0n) {
+            return -9223372036854775808n;
+          }
+          return sum_0;
+        }
+      }
+      jp(duration) {
+        // Inline function 'kotlin.time.Duration.toComponents' call
+        var tmp0 = _Duration___get_inWholeSeconds__impl__hpy7b3(duration);
+        var nanosecondsToAdd = _Duration___get_nanosecondsComponent__impl__nh19kq(duration);
+        if (tmp0 === 0n && nanosecondsToAdd === 0) {
+          return this;
+        }
+        // Inline function 'kotlin.time.safeAddOrElse' call
+        var a = this.gp_1;
+        var sum = add(a, tmp0);
+        if ((a ^ sum) < 0n && (a ^ tmp0) >= 0n) {
+          return Duration__isPositive_impl_tvkkt2(duration) ? Companion_getInstance_0().di_1 : Companion_getInstance_0().ci_1;
+        }
+        var newEpochSeconds = sum;
+        var nanoAdjustment = this.hp_1 + nanosecondsToAdd | 0;
+        return Companion_getInstance_0().bp(newEpochSeconds, nanoAdjustment);
+      }
+      kp(duration) {
+        return this.jp(Duration__unaryMinus_impl_x2k1y0(duration));
+      }
+      lp(other) {
+        Companion_getInstance();
+        // Inline function 'kotlin.time.Companion.seconds' call
+        var this_0 = subtract(this.gp_1, other.gp_1);
+        var tmp = toDuration(this_0, DurationUnit_SECONDS_getInstance());
+        Companion_getInstance();
+        // Inline function 'kotlin.time.Companion.nanoseconds' call
+        var this_1 = this.hp_1 - other.hp_1 | 0;
+        var tmp$ret$1 = toDuration_0(this_1, DurationUnit_NANOSECONDS_getInstance());
+        return Duration__plus_impl_yu9v8f(tmp, tmp$ret$1);
+      }
+      mp(other) {
+        var s = compareTo(this.gp_1, other.gp_1);
+        if (!(s === 0)) {
+          return s;
+        }
+        return compareTo(this.hp_1, other.hp_1);
+      }
+      d(other) {
+        return this.mp(other instanceof Instant() ? other : THROW_CCE());
+      }
+      equals(other) {
+        var tmp;
+        if (this === other) {
+          tmp = true;
+        } else {
+          var tmp_0;
+          var tmp_1;
+          if (other instanceof Instant()) {
+            tmp_1 = this.gp_1 === other.gp_1;
+          } else {
+            tmp_1 = false;
+          }
+          if (tmp_1) {
+            tmp_0 = this.hp_1 === other.hp_1;
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return getBigIntHashCode(this.gp_1) + imul(51, this.hp_1) | 0;
+      }
+      toString() {
+        return formatIso(this);
+      }
+    }
+    initMetadataForClass($, 'Instant', VOID, VOID, [Comparable()]);
+    InstantClass = $;
+  }
+  return InstantClass;
+}
+function formatIso(instant) {
+  _init_properties_Instant_kt__2myitt();
+  // Inline function 'kotlin.text.buildString' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = StringBuilder().x();
+  var ldt = Companion_instance_0.np(instant);
+  // Inline function 'kotlin.run' call
+  var number = ldt.op_1;
+  var tmp;
+  // Inline function 'kotlin.math.absoluteValue' call
+  if (abs(number) < 1000) {
+    var innerBuilder = StringBuilder().x();
+    if (number >= 0) {
+      // Inline function 'kotlin.text.deleteAt' call
+      innerBuilder.vg(number + 10000 | 0).ah(0);
+    } else {
+      // Inline function 'kotlin.text.deleteAt' call
+      innerBuilder.vg(number - 10000 | 0).ah(1);
+    }
+    tmp = this_0.b1(innerBuilder);
+  } else {
+    if (number >= 10000) {
+      this_0.pb(_Char___init__impl__6a9atx(43));
+    }
+    tmp = this_0.vg(number);
+  }
+  this_0.pb(_Char___init__impl__6a9atx(45));
+  formatIso$_anonymous_$appendTwoDigits_ydzygl(this_0, this_0, ldt.pp_1);
+  this_0.pb(_Char___init__impl__6a9atx(45));
+  formatIso$_anonymous_$appendTwoDigits_ydzygl(this_0, this_0, ldt.qp_1);
+  this_0.pb(_Char___init__impl__6a9atx(84));
+  formatIso$_anonymous_$appendTwoDigits_ydzygl(this_0, this_0, ldt.rp_1);
+  this_0.pb(_Char___init__impl__6a9atx(58));
+  formatIso$_anonymous_$appendTwoDigits_ydzygl(this_0, this_0, ldt.sp_1);
+  this_0.pb(_Char___init__impl__6a9atx(58));
+  formatIso$_anonymous_$appendTwoDigits_ydzygl(this_0, this_0, ldt.tp_1);
+  if (!(ldt.up_1 === 0)) {
+    this_0.pb(_Char___init__impl__6a9atx(46));
+    var zerosToStrip = 0;
+    while ((ldt.up_1 % get_POWERS_OF_TEN()[zerosToStrip + 1 | 0] | 0) === 0) {
+      zerosToStrip = zerosToStrip + 1 | 0;
+    }
+    zerosToStrip = zerosToStrip - (zerosToStrip % 3 | 0) | 0;
+    var numberToOutput = ldt.up_1 / get_POWERS_OF_TEN()[zerosToStrip] | 0;
+    this_0.ob(substring((numberToOutput + get_POWERS_OF_TEN()[9 - zerosToStrip | 0] | 0).toString(), 1));
+  }
+  this_0.pb(_Char___init__impl__6a9atx(90));
+  return this_0.toString();
+}
+var SuccessClass;
+function Success() {
+  if (SuccessClass === VOID) {
+    class $ {
+      constructor(epochSeconds, nanosecondsOfSecond) {
+        this.vp_1 = epochSeconds;
+        this.wp_1 = nanosecondsOfSecond;
+      }
+      fp() {
+        if (this.vp_1 < Companion_getInstance_0().ci_1.gp_1 || this.vp_1 > Companion_getInstance_0().di_1.gp_1)
+          throw InstantFormatException().bq('The parsed date is outside the range representable by Instant (Unix epoch second ' + this.vp_1.toString() + ')');
+        return Companion_getInstance_0().bp(this.vp_1, this.wp_1);
+      }
+    }
+    initMetadataForClass($, 'Success');
+    SuccessClass = $;
+  }
+  return SuccessClass;
+}
+var FailureClass;
+function Failure() {
+  if (FailureClass === VOID) {
+    class $ {
+      constructor(error, input) {
+        this.cq_1 = error;
+        this.dq_1 = input;
+      }
+      fp() {
+        throw InstantFormatException().bq(this.cq_1 + ' when parsing an Instant from "' + truncateForErrorMessage(this.dq_1, 64) + '"');
+      }
+    }
+    initMetadataForClass($, 'Failure');
+    FailureClass = $;
+  }
+  return FailureClass;
+}
+function parseIso(isoString) {
+  _init_properties_Instant_kt__2myitt();
+  var s = isoString;
+  var i = 0;
+  // Inline function 'kotlin.text.isEmpty' call
+  if (charSequenceLength(s) === 0) {
+    return new (Failure())('An empty string is not a valid Instant', isoString);
+  }
+  var c = charSequenceGet(s, i);
+  var tmp;
+  if (c === _Char___init__impl__6a9atx(43) || c === _Char___init__impl__6a9atx(45)) {
+    i = i + 1 | 0;
+    tmp = c;
+  } else {
+    tmp = _Char___init__impl__6a9atx(32);
+  }
+  var yearSign = tmp;
+  var yearStart = i;
+  var absYear = 0;
+  $l$loop: while (true) {
+    var tmp_0;
+    if (i < charSequenceLength(s)) {
+      var containsArg = charSequenceGet(s, i);
+      tmp_0 = _Char___init__impl__6a9atx(48) <= containsArg ? containsArg <= _Char___init__impl__6a9atx(57) : false;
+    } else {
+      tmp_0 = false;
+    }
+    if (!tmp_0) {
+      break $l$loop;
+    }
+    absYear = imul(absYear, 10) + Char__minus_impl_a2frrh(charSequenceGet(s, i), _Char___init__impl__6a9atx(48)) | 0;
+    i = i + 1 | 0;
+  }
+  var yearStrLength = i - yearStart | 0;
+  var tmp_1;
+  if (yearStrLength > 10) {
+    return parseIso$parseFailure(isoString, 'Expected at most 10 digits for the year number, got ' + yearStrLength + ' digits');
+  } else if (yearStrLength === 10 && Char__compareTo_impl_ypi4mb(charSequenceGet(s, yearStart), _Char___init__impl__6a9atx(50)) >= 0) {
+    return parseIso$parseFailure(isoString, 'Expected at most 9 digits for the year number or year 1000000000, got ' + yearStrLength + ' digits');
+  } else if (yearStrLength < 4) {
+    return parseIso$parseFailure(isoString, 'The year number must be padded to 4 digits, got ' + yearStrLength + ' digits');
+  } else {
+    if (yearSign === _Char___init__impl__6a9atx(43) && yearStrLength === 4) {
+      return parseIso$parseFailure(isoString, "The '+' sign at the start is only valid for year numbers longer than 4 digits");
+    }
+    if (yearSign === _Char___init__impl__6a9atx(32) && !(yearStrLength === 4)) {
+      return parseIso$parseFailure(isoString, "A '+' or '-' sign is required for year numbers longer than 4 digits");
+    }
+    tmp_1 = yearSign === _Char___init__impl__6a9atx(45) ? -absYear | 0 : absYear;
+  }
+  var year = tmp_1;
+  if (charSequenceLength(s) < (i + 16 | 0)) {
+    return parseIso$parseFailure(isoString, 'The input string is too short');
+  }
+  var tmp_2 = i;
+  var tmp0_safe_receiver = parseIso$expect(isoString, "'-'", tmp_2, parseIso$lambda);
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    return tmp0_safe_receiver;
+  }
+  var tmp_3 = i + 3 | 0;
+  var tmp1_safe_receiver = parseIso$expect(isoString, "'-'", tmp_3, parseIso$lambda_0);
+  if (tmp1_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    return tmp1_safe_receiver;
+  }
+  var tmp_4 = i + 6 | 0;
+  var tmp2_safe_receiver = parseIso$expect(isoString, "'T' or 't'", tmp_4, parseIso$lambda_1);
+  if (tmp2_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    return tmp2_safe_receiver;
+  }
+  var tmp_5 = i + 9 | 0;
+  var tmp3_safe_receiver = parseIso$expect(isoString, "':'", tmp_5, parseIso$lambda_2);
+  if (tmp3_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    return tmp3_safe_receiver;
+  }
+  var tmp_6 = i + 12 | 0;
+  var tmp4_safe_receiver = parseIso$expect(isoString, "':'", tmp_6, parseIso$lambda_3);
+  if (tmp4_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    return tmp4_safe_receiver;
+  }
+  var indexedObject = get_asciiDigitPositionsInIsoStringAfterYear();
+  var inductionVariable = 0;
+  var last = indexedObject.length;
+  while (inductionVariable < last) {
+    var j = indexedObject[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    var tmp_7 = i + j | 0;
+    var tmp5_safe_receiver = parseIso$expect(isoString, 'an ASCII digit', tmp_7, parseIso$lambda_4);
+    if (tmp5_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      return tmp5_safe_receiver;
+    }
+  }
+  var month = parseIso$twoDigitNumber(s, i + 1 | 0);
+  var day = parseIso$twoDigitNumber(s, i + 4 | 0);
+  var hour = parseIso$twoDigitNumber(s, i + 7 | 0);
+  var minute = parseIso$twoDigitNumber(s, i + 10 | 0);
+  var second = parseIso$twoDigitNumber(s, i + 13 | 0);
+  var tmp_8;
+  if (charSequenceGet(s, i + 15 | 0) === _Char___init__impl__6a9atx(46)) {
+    var fractionStart = i + 16 | 0;
+    i = fractionStart;
+    var fraction = 0;
+    $l$loop_0: while (true) {
+      var tmp_9;
+      if (i < charSequenceLength(s)) {
+        var containsArg_0 = charSequenceGet(s, i);
+        tmp_9 = _Char___init__impl__6a9atx(48) <= containsArg_0 ? containsArg_0 <= _Char___init__impl__6a9atx(57) : false;
+      } else {
+        tmp_9 = false;
+      }
+      if (!tmp_9) {
+        break $l$loop_0;
+      }
+      fraction = imul(fraction, 10) + Char__minus_impl_a2frrh(charSequenceGet(s, i), _Char___init__impl__6a9atx(48)) | 0;
+      i = i + 1 | 0;
+    }
+    var fractionStrLength = i - fractionStart | 0;
+    var tmp_10;
+    if (1 <= fractionStrLength ? fractionStrLength <= 9 : false) {
+      tmp_10 = imul(fraction, get_POWERS_OF_TEN()[9 - fractionStrLength | 0]);
+    } else {
+      return parseIso$parseFailure(isoString, '1..9 digits are supported for the fraction of the second, got ' + fractionStrLength + ' digits');
+    }
+    tmp_8 = tmp_10;
+  } else {
+    i = i + 15 | 0;
+    tmp_8 = 0;
+  }
+  var nanosecond = tmp_8;
+  if (i >= charSequenceLength(s)) {
+    return parseIso$parseFailure(isoString, 'The UTC offset at the end of the string is missing');
+  }
+  var sign = charSequenceGet(s, i);
+  var tmp_11;
+  if (sign === _Char___init__impl__6a9atx(122) || sign === _Char___init__impl__6a9atx(90)) {
+    var tmp_12;
+    if (charSequenceLength(s) === (i + 1 | 0)) {
+      tmp_12 = 0;
+    } else {
+      return parseIso$parseFailure(isoString, 'Extra text after the instant at position ' + (i + 1 | 0));
+    }
+    tmp_11 = tmp_12;
+  } else if (sign === _Char___init__impl__6a9atx(45) || sign === _Char___init__impl__6a9atx(43)) {
+    var offsetStrLength = charSequenceLength(s) - i | 0;
+    if (offsetStrLength > 9) {
+      // Inline function 'kotlin.text.substring' call
+      var startIndex = i;
+      var endIndex = charSequenceLength(s);
+      var tmp$ret$7 = toString(charSequenceSubSequence(s, startIndex, endIndex));
+      return parseIso$parseFailure(isoString, 'The UTC offset string "' + truncateForErrorMessage(tmp$ret$7, 16) + '" is too long');
+    }
+    if (!((offsetStrLength % 3 | 0) === 0)) {
+      // Inline function 'kotlin.text.substring' call
+      var startIndex_0 = i;
+      var endIndex_0 = charSequenceLength(s);
+      var tmp$ret$8 = toString(charSequenceSubSequence(s, startIndex_0, endIndex_0));
+      return parseIso$parseFailure(isoString, 'Invalid UTC offset string "' + tmp$ret$8 + '"');
+    }
+    var indexedObject_0 = get_colonsInIsoOffsetString();
+    var inductionVariable_0 = 0;
+    var last_0 = indexedObject_0.length;
+    $l$loop_1: while (inductionVariable_0 < last_0) {
+      var j_0 = indexedObject_0[inductionVariable_0];
+      inductionVariable_0 = inductionVariable_0 + 1 | 0;
+      if ((i + j_0 | 0) >= charSequenceLength(s))
+        break $l$loop_1;
+      if (!(charSequenceGet(s, i + j_0 | 0) === _Char___init__impl__6a9atx(58)))
+        return parseIso$parseFailure(isoString, "Expected ':' at index " + (i + j_0 | 0) + ", got '" + toString_0(charSequenceGet(s, i + j_0 | 0)) + "'");
+    }
+    var indexedObject_1 = get_asciiDigitsInIsoOffsetString();
+    var inductionVariable_1 = 0;
+    var last_1 = indexedObject_1.length;
+    $l$loop_2: while (inductionVariable_1 < last_1) {
+      var j_1 = indexedObject_1[inductionVariable_1];
+      inductionVariable_1 = inductionVariable_1 + 1 | 0;
+      if ((i + j_1 | 0) >= charSequenceLength(s))
+        break $l$loop_2;
+      var containsArg_1 = charSequenceGet(s, i + j_1 | 0);
+      if (!(_Char___init__impl__6a9atx(48) <= containsArg_1 ? containsArg_1 <= _Char___init__impl__6a9atx(57) : false))
+        return parseIso$parseFailure(isoString, 'Expected an ASCII digit at index ' + (i + j_1 | 0) + ", got '" + toString_0(charSequenceGet(s, i + j_1 | 0)) + "'");
+    }
+    var offsetHour = parseIso$twoDigitNumber(s, i + 1 | 0);
+    var tmp_13;
+    if (offsetStrLength > 3) {
+      tmp_13 = parseIso$twoDigitNumber(s, i + 4 | 0);
+    } else {
+      tmp_13 = 0;
+    }
+    var offsetMinute = tmp_13;
+    var tmp_14;
+    if (offsetStrLength > 6) {
+      tmp_14 = parseIso$twoDigitNumber(s, i + 7 | 0);
+    } else {
+      tmp_14 = 0;
+    }
+    var offsetSecond = tmp_14;
+    if (offsetMinute > 59) {
+      return parseIso$parseFailure(isoString, 'Expected offset-minute-of-hour in 0..59, got ' + offsetMinute);
+    }
+    if (offsetSecond > 59) {
+      return parseIso$parseFailure(isoString, 'Expected offset-second-of-minute in 0..59, got ' + offsetSecond);
+    }
+    if (offsetHour > 17 && !(offsetHour === 18 && offsetMinute === 0 && offsetSecond === 0)) {
+      // Inline function 'kotlin.text.substring' call
+      var startIndex_1 = i;
+      var endIndex_1 = charSequenceLength(s);
+      var tmp$ret$9 = toString(charSequenceSubSequence(s, startIndex_1, endIndex_1));
+      return parseIso$parseFailure(isoString, 'Expected an offset in -18:00..+18:00, got ' + tmp$ret$9);
+    }
+    tmp_11 = imul((imul(offsetHour, 3600) + imul(offsetMinute, 60) | 0) + offsetSecond | 0, sign === _Char___init__impl__6a9atx(45) ? -1 : 1);
+  } else {
+    return parseIso$parseFailure(isoString, 'Expected the UTC offset at position ' + i + ", got '" + toString_0(sign) + "'");
+  }
+  var offsetSeconds = tmp_11;
+  if (!(1 <= month ? month <= 12 : false)) {
+    return parseIso$parseFailure(isoString, 'Expected a month number in 1..12, got ' + month);
+  }
+  if (!(1 <= day ? day <= monthLength(month, isLeapYear(year)) : false)) {
+    return parseIso$parseFailure(isoString, 'Expected a valid day-of-month for month ' + month + ' of year ' + year + ', got ' + day);
+  }
+  if (hour > 23) {
+    return parseIso$parseFailure(isoString, 'Expected hour in 0..23, got ' + hour);
+  }
+  if (minute > 59) {
+    return parseIso$parseFailure(isoString, 'Expected minute-of-hour in 0..59, got ' + minute);
+  }
+  if (second > 59) {
+    return parseIso$parseFailure(isoString, 'Expected second-of-minute in 0..59, got ' + second);
+  }
+  // Inline function 'kotlin.time.UnboundLocalDateTime.toInstant' call
+  var this_0 = new (UnboundLocalDateTime())(year, month, day, hour, minute, second, nanosecond);
+  // Inline function 'kotlin.run' call
+  // Inline function 'kotlin.run' call
+  var y = fromInt(this_0.op_1);
+  var total = multiply(numberToLong(365), y);
+  if (y >= 0n) {
+    var tmp_15 = total;
+    // Inline function 'kotlin.Long.plus' call
+    // Inline function 'kotlin.Long.div' call
+    var this_1 = add(y, fromInt(3));
+    var tmp_16 = divide(this_1, fromInt(4));
+    // Inline function 'kotlin.Long.plus' call
+    // Inline function 'kotlin.Long.div' call
+    var this_2 = add(y, fromInt(99));
+    var tmp$ret$13 = divide(this_2, fromInt(100));
+    var tmp_17 = subtract(tmp_16, tmp$ret$13);
+    // Inline function 'kotlin.Long.plus' call
+    // Inline function 'kotlin.Long.div' call
+    var this_3 = add(y, fromInt(399));
+    var tmp$ret$15 = divide(this_3, fromInt(400));
+    total = add(tmp_15, add(tmp_17, tmp$ret$15));
+  } else {
+    var tmp_18 = total;
+    // Inline function 'kotlin.Long.div' call
+    var tmp_19 = divide(y, fromInt(-4));
+    // Inline function 'kotlin.Long.div' call
+    var tmp$ret$17 = divide(y, fromInt(-100));
+    var tmp_20 = subtract(tmp_19, tmp$ret$17);
+    // Inline function 'kotlin.Long.div' call
+    var tmp$ret$18 = divide(y, fromInt(-400));
+    total = subtract(tmp_18, add(tmp_20, tmp$ret$18));
+  }
+  var tmp0 = total;
+  // Inline function 'kotlin.Long.plus' call
+  var other = (imul(367, this_0.pp_1) - 362 | 0) / 12 | 0;
+  total = add(tmp0, fromInt(other));
+  var tmp0_0 = total;
+  // Inline function 'kotlin.Long.plus' call
+  var other_0 = this_0.qp_1 - 1 | 0;
+  total = add(tmp0_0, fromInt(other_0));
+  if (this_0.pp_1 > 2) {
+    var _unary__edvuaz = total;
+    total = subtract(_unary__edvuaz, get_ONE());
+    if (!isLeapYear(this_0.op_1)) {
+      var _unary__edvuaz_0 = total;
+      total = subtract(_unary__edvuaz_0, get_ONE());
+    }
+  }
+  // Inline function 'kotlin.Long.minus' call
+  var this_4 = total;
+  var epochDays = subtract(this_4, fromInt(719528));
+  var daySeconds = (imul(this_0.rp_1, 3600) + imul(this_0.sp_1, 60) | 0) + this_0.tp_1 | 0;
+  // Inline function 'kotlin.Long.times' call
+  // Inline function 'kotlin.Long.plus' call
+  var this_5 = multiply(epochDays, fromInt(86400));
+  // Inline function 'kotlin.Long.minus' call
+  var this_6 = add(this_5, fromInt(daySeconds));
+  var epochSeconds = subtract(this_6, fromInt(offsetSeconds));
+  var p1 = this_0.up_1;
+  return new (Success())(epochSeconds, p1);
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {
+      np(instant) {
+        var localSecond = instant.gp_1;
+        // Inline function 'kotlin.floorDiv' call
+        var q = divide(localSecond, 86400n);
+        if ((localSecond ^ 86400n) < 0n && !(multiply(q, 86400n) === localSecond)) {
+          var _unary__edvuaz = q;
+          q = subtract(_unary__edvuaz, get_ONE());
+        }
+        var epochDays = q;
+        // Inline function 'kotlin.mod' call
+        var r = modulo(localSecond, 86400n);
+        var tmp$ret$1 = add(r, 86400n & shiftRight((r ^ 86400n) & (r | negate(r)), 63));
+        var secsOfDay = convertToInt(tmp$ret$1);
+        var year;
+        var month;
+        var day;
+        // Inline function 'kotlin.run' call
+        // Inline function 'kotlin.Long.plus' call
+        var zeroDay = add(epochDays, fromInt(719528));
+        // Inline function 'kotlin.Long.minus' call
+        var this_0 = zeroDay;
+        zeroDay = subtract(this_0, fromInt(60));
+        var adjust = 0n;
+        if (zeroDay < 0n) {
+          // Inline function 'kotlin.Long.plus' call
+          var this_1 = zeroDay;
+          // Inline function 'kotlin.Long.div' call
+          var this_2 = add(this_1, fromInt(1));
+          // Inline function 'kotlin.Long.minus' call
+          var this_3 = divide(this_2, fromInt(146097));
+          var adjustCycles = subtract(this_3, fromInt(1));
+          // Inline function 'kotlin.Long.times' call
+          adjust = multiply(adjustCycles, fromInt(400));
+          var tmp = zeroDay;
+          // Inline function 'kotlin.Long.times' call
+          var this_4 = negate(adjustCycles);
+          var tmp$ret$8 = multiply(this_4, fromInt(146097));
+          zeroDay = add(tmp, tmp$ret$8);
+        }
+        // Inline function 'kotlin.Long.plus' call
+        var this_5 = multiply(numberToLong(400), zeroDay);
+        // Inline function 'kotlin.Long.div' call
+        var this_6 = add(this_5, fromInt(591));
+        var yearEst = divide(this_6, fromInt(146097));
+        var tmp_0 = zeroDay;
+        var tmp_1 = multiply(numberToLong(365), yearEst);
+        // Inline function 'kotlin.Long.div' call
+        var this_7 = yearEst;
+        var tmp$ret$11 = divide(this_7, fromInt(4));
+        var tmp_2 = add(tmp_1, tmp$ret$11);
+        // Inline function 'kotlin.Long.div' call
+        var this_8 = yearEst;
+        var tmp$ret$12 = divide(this_8, fromInt(100));
+        var tmp_3 = subtract(tmp_2, tmp$ret$12);
+        // Inline function 'kotlin.Long.div' call
+        var this_9 = yearEst;
+        var tmp$ret$13 = divide(this_9, fromInt(400));
+        var doyEst = subtract(tmp_0, add(tmp_3, tmp$ret$13));
+        if (doyEst < 0n) {
+          var _unary__edvuaz_0 = yearEst;
+          yearEst = subtract(_unary__edvuaz_0, get_ONE());
+          var tmp_4 = zeroDay;
+          var tmp_5 = multiply(numberToLong(365), yearEst);
+          // Inline function 'kotlin.Long.div' call
+          var this_10 = yearEst;
+          var tmp$ret$14 = divide(this_10, fromInt(4));
+          var tmp_6 = add(tmp_5, tmp$ret$14);
+          // Inline function 'kotlin.Long.div' call
+          var this_11 = yearEst;
+          var tmp$ret$15 = divide(this_11, fromInt(100));
+          var tmp_7 = subtract(tmp_6, tmp$ret$15);
+          // Inline function 'kotlin.Long.div' call
+          var this_12 = yearEst;
+          var tmp$ret$16 = divide(this_12, fromInt(400));
+          doyEst = subtract(tmp_4, add(tmp_7, tmp$ret$16));
+        }
+        yearEst = add(yearEst, adjust);
+        var marchDoy0 = convertToInt(doyEst);
+        var marchMonth0 = (imul(marchDoy0, 5) + 2 | 0) / 153 | 0;
+        month = ((marchMonth0 + 2 | 0) % 12 | 0) + 1 | 0;
+        day = (marchDoy0 - ((imul(marchMonth0, 306) + 5 | 0) / 10 | 0) | 0) + 1 | 0;
+        var tmp0 = yearEst;
+        // Inline function 'kotlin.Long.plus' call
+        var other = marchMonth0 / 10 | 0;
+        var tmp$ret$17 = add(tmp0, fromInt(other));
+        year = convertToInt(tmp$ret$17);
+        var hours = secsOfDay / 3600 | 0;
+        var secondWithoutHours = secsOfDay - imul(hours, 3600) | 0;
+        var minutes = secondWithoutHours / 60 | 0;
+        var second = secondWithoutHours - imul(minutes, 60) | 0;
+        return new (UnboundLocalDateTime())(year, month, day, hours, minutes, second, instant.hp_1);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_1() {
+  return Companion_instance_0;
+}
+var UnboundLocalDateTimeClass;
+function UnboundLocalDateTime() {
+  if (UnboundLocalDateTimeClass === VOID) {
+    class $ {
+      constructor(year, month, day, hour, minute, second, nanosecond) {
+        this.op_1 = year;
+        this.pp_1 = month;
+        this.qp_1 = day;
+        this.rp_1 = hour;
+        this.sp_1 = minute;
+        this.tp_1 = second;
+        this.up_1 = nanosecond;
+      }
+      toString() {
+        return 'UnboundLocalDateTime(' + this.op_1 + '-' + this.pp_1 + '-' + this.qp_1 + ' ' + this.rp_1 + ':' + this.sp_1 + ':' + this.tp_1 + '.' + this.up_1 + ')';
+      }
+    }
+    initMetadataForClass($, 'UnboundLocalDateTime');
+    UnboundLocalDateTimeClass = $;
+  }
+  return UnboundLocalDateTimeClass;
+}
+var InstantFormatExceptionClass;
+function InstantFormatException() {
+  if (InstantFormatExceptionClass === VOID) {
+    class $ extends IllegalArgumentException() {
+      static bq(message) {
+        var $this = this.j1(message);
+        captureStack($this, $this.aq_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'InstantFormatException');
+    InstantFormatExceptionClass = $;
+  }
+  return InstantFormatExceptionClass;
+}
+function truncateForErrorMessage(_this__u8e3s4, maxLength) {
+  _init_properties_Instant_kt__2myitt();
+  var tmp;
+  if (charSequenceLength(_this__u8e3s4) <= maxLength) {
+    tmp = toString(_this__u8e3s4);
+  } else {
+    // Inline function 'kotlin.text.substring' call
+    tmp = toString(charSequenceSubSequence(_this__u8e3s4, 0, maxLength)) + '...';
+  }
+  return tmp;
+}
+function monthLength(_this__u8e3s4, isLeapYear) {
+  _init_properties_Instant_kt__2myitt();
+  switch (_this__u8e3s4) {
+    case 2:
+      return isLeapYear ? 29 : 28;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+    default:
+      return 31;
+  }
+}
+function isLeapYear(year) {
+  _init_properties_Instant_kt__2myitt();
+  return (year & 3) === 0 && (!((year % 100 | 0) === 0) || (year % 400 | 0) === 0);
+}
+function formatIso$_anonymous_$appendTwoDigits_ydzygl(_this__u8e3s4, $this_buildString, number) {
+  if (number < 10) {
+    _this__u8e3s4.pb(_Char___init__impl__6a9atx(48));
+  }
+  $this_buildString.vg(number);
+}
+function parseIso$parseFailure($isoString, error) {
+  return new (Failure())(error + ' when parsing an Instant from "' + truncateForErrorMessage($isoString, 64) + '"', $isoString);
+}
+function parseIso$expect($isoString, what, where, predicate) {
+  var c = charSequenceGet($isoString, where);
+  var tmp;
+  if (predicate(new (Char())(c))) {
+    tmp = null;
+  } else {
+    tmp = parseIso$parseFailure($isoString, 'Expected ' + what + ", but got '" + toString_0(c) + "' at position " + where);
+  }
+  return tmp;
+}
+function parseIso$twoDigitNumber(s, index) {
+  return imul(Char__minus_impl_a2frrh(charSequenceGet(s, index), _Char___init__impl__6a9atx(48)), 10) + Char__minus_impl_a2frrh(charSequenceGet(s, index + 1 | 0), _Char___init__impl__6a9atx(48)) | 0;
+}
+function parseIso$lambda(it) {
+  _init_properties_Instant_kt__2myitt();
+  return equals(it, new (Char())(_Char___init__impl__6a9atx(45)));
+}
+function parseIso$lambda_0(it) {
+  _init_properties_Instant_kt__2myitt();
+  return equals(it, new (Char())(_Char___init__impl__6a9atx(45)));
+}
+function parseIso$lambda_1(it) {
+  _init_properties_Instant_kt__2myitt();
+  return equals(it, new (Char())(_Char___init__impl__6a9atx(84))) || equals(it, new (Char())(_Char___init__impl__6a9atx(116)));
+}
+function parseIso$lambda_2(it) {
+  _init_properties_Instant_kt__2myitt();
+  return equals(it, new (Char())(_Char___init__impl__6a9atx(58)));
+}
+function parseIso$lambda_3(it) {
+  _init_properties_Instant_kt__2myitt();
+  return equals(it, new (Char())(_Char___init__impl__6a9atx(58)));
+}
+function parseIso$lambda_4(it) {
+  _init_properties_Instant_kt__2myitt();
+  var containsArg = it.q2_1;
+  return _Char___init__impl__6a9atx(48) <= containsArg ? containsArg <= _Char___init__impl__6a9atx(57) : false;
+}
+var properties_initialized_Instant_kt_xip69;
+function _init_properties_Instant_kt__2myitt() {
+  if (!properties_initialized_Instant_kt_xip69) {
+    properties_initialized_Instant_kt_xip69 = true;
+    // Inline function 'kotlin.intArrayOf' call
+    POWERS_OF_TEN = new Int32Array([1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000]);
+    // Inline function 'kotlin.intArrayOf' call
+    asciiDigitPositionsInIsoStringAfterYear = new Int32Array([1, 2, 4, 5, 7, 8, 10, 11, 13, 14]);
+    // Inline function 'kotlin.intArrayOf' call
+    colonsInIsoOffsetString = new Int32Array([3, 6]);
+    // Inline function 'kotlin.intArrayOf' call
+    asciiDigitsInIsoOffsetString = new Int32Array([1, 2, 4, 5, 7, 8]);
+  }
+}
+//region block: init
+Companion_instance_0 = new (Companion_0())();
+//endregion
+//region block: exports
+export {
+  Companion_getInstance_0 as Companion_getInstance1jfygh5e58evr,
+  Instant as Instant2s2zyzgfc4947,
+};
+//endregion
+
+//# sourceMappingURL=Instant.mjs.map