@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,865 @@
+import { Long2qws0ah9gnpki as Long } from '../Primitives.mjs';
+import {
+  divide3tol6kxdi8xn6 as divide,
+  get_ONEazvfdh9ju3d4 as get_ONE,
+  subtract16cg4lfi29fq9 as subtract,
+  bitwiseXor10gmbxn4rolze as bitwiseXor,
+  compare2uud5j30pw5xc as compare,
+  multiply18i3gv3wlmcjg as multiply,
+  equalsLong28bsrfhwvd686 as equalsLong,
+  modulo3mmbfwxzpcw3a as modulo,
+  negate12tprdg5pyd5t as negate,
+  bitwiseOr1ita6dahwp8zb as bitwiseOr,
+  bitwiseAnd2g7wmsfd45l12 as bitwiseAnd,
+  shiftRight2cr6y79ufiihy as shiftRight,
+  add85si75olwt6n as add,
+  fromInt1lka3ktyu79a4 as fromInt,
+  convertToIntofdoxh9bstof as convertToInt,
+  numberToLong345n6tb1n1i71 as numberToLong,
+} from '../js/internal/boxedLong/boxedLong.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../Unit.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../exceptions.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  captureStack1fzi4aczwc4hg as captureStack,
+  equals2au1ep9vhcato as equals,
+} from '../js/coreRuntime.mjs';
+import {
+  Companion_getInstance1ji65oeucwbu1 as Companion_getInstance,
+  toDurationba1nlt78o6vu as toDuration,
+  toDuration7gy6v749ektt as toDuration_0,
+  Duration__plus_impl_yu9v8f3u0ccraw6vska as Duration__plus_impl_yu9v8f,
+} from './Duration.mjs';
+import {
+  DurationUnit_SECONDS_getInstance3kr54qc67slio as DurationUnit_SECONDS_getInstance,
+  DurationUnit_NANOSECONDS_getInstance21q7hkfzg8ym5 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__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
+  Char__minus_impl_a2frrh1dka2ec6zg6dk as Char__minus_impl_a2frrh,
+  Char__compareTo_impl_ypi4mb3frsmupst9pih as Char__compareTo_impl_ypi4mb,
+  toString3dhdjl9yf50de 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.ij_1 = new (Instant())(new (Long())(342103040, -7347440), 0);
+        this.jj_1 = new (Instant())(new (Long())(-90867457, 7347410), 999999999);
+      }
+      kj(epochMilliseconds) {
+        // Inline function 'kotlin.floorDiv' call
+        var other = new (Long())(1000, 0);
+        var q = divide(epochMilliseconds, other);
+        if (compare(bitwiseXor(epochMilliseconds, other), new (Long())(0, 0)) < 0 && !equalsLong(multiply(q, other), epochMilliseconds)) {
+          var _unary__edvuaz = q;
+          q = subtract(_unary__edvuaz, get_ONE());
+        }
+        var epochSeconds = q;
+        // Inline function 'kotlin.mod' call
+        var other_0 = new (Long())(1000, 0);
+        var r = modulo(epochMilliseconds, other_0);
+        // Inline function 'kotlin.Long.times' call
+        var this_0 = add(r, bitwiseAnd(other_0, shiftRight(bitwiseAnd(bitwiseXor(r, other_0), bitwiseOr(r, negate(r))), 63)));
+        var tmp$ret$2 = multiply(this_0, fromInt(1000000));
+        var nanosecondsOfSecond = convertToInt(tmp$ret$2);
+        return compare(epochSeconds, new (Long())(342103040, -7347440)) < 0 ? this.ij_1 : compare(epochSeconds, new (Long())(-90867457, 7347410)) > 0 ? this.jj_1 : this.xr(epochSeconds, nanosecondsOfSecond);
+      }
+      yr(epochSeconds, nanosecondAdjustment) {
+        // Inline function 'kotlin.floorDiv' call
+        var other = new (Long())(1000000000, 0);
+        var q = divide(nanosecondAdjustment, other);
+        if (compare(bitwiseXor(nanosecondAdjustment, other), new (Long())(0, 0)) < 0 && !equalsLong(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 (compare(bitwiseXor(epochSeconds, sum), new (Long())(0, 0)) < 0 && compare(bitwiseXor(epochSeconds, b), new (Long())(0, 0)) >= 0) {
+          return compare(epochSeconds, new (Long())(0, 0)) > 0 ? Companion_getInstance_0().jj_1 : Companion_getInstance_0().ij_1;
+        }
+        var seconds = sum;
+        var tmp;
+        if (compare(seconds, new (Long())(342103040, -7347440)) < 0) {
+          tmp = this.ij_1;
+        } else if (compare(seconds, new (Long())(-90867457, 7347410)) > 0) {
+          tmp = this.jj_1;
+        } else {
+          // Inline function 'kotlin.mod' call
+          var other_0 = new (Long())(1000000000, 0);
+          var r = modulo(nanosecondAdjustment, other_0);
+          var tmp$ret$2 = add(r, bitwiseAnd(other_0, shiftRight(bitwiseAnd(bitwiseXor(r, other_0), bitwiseOr(r, negate(r))), 63)));
+          var nanoseconds = convertToInt(tmp$ret$2);
+          tmp = new (Instant())(seconds, nanoseconds);
+        }
+        return tmp;
+      }
+      xr(epochSeconds, nanosecondAdjustment) {
+        return this.yr(epochSeconds, fromInt(nanosecondAdjustment));
+      }
+      zr(input) {
+        return parseIso(input).as();
+      }
+    }
+    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.bs_1 = epochSeconds;
+        this.cs_1 = nanosecondsOfSecond;
+        var containsArg = this.bs_1;
+        // Inline function 'kotlin.require' call
+        if (!(compare(new (Long())(342103040, -7347440), containsArg) <= 0 ? compare(containsArg, new (Long())(-90867457, 7347410)) <= 0 : false)) {
+          var message = 'Instant exceeds minimum or maximum instant';
+          throw IllegalArgumentException().r2(toString(message));
+        }
+      }
+      ds(other) {
+        Companion_getInstance();
+        // Inline function 'kotlin.time.Companion.seconds' call
+        var this_0 = subtract(this.bs_1, other.bs_1);
+        var tmp = toDuration(this_0, DurationUnit_SECONDS_getInstance());
+        Companion_getInstance();
+        // Inline function 'kotlin.time.Companion.nanoseconds' call
+        var this_1 = this.cs_1 - other.cs_1 | 0;
+        var tmp$ret$1 = toDuration_0(this_1, DurationUnit_NANOSECONDS_getInstance());
+        return Duration__plus_impl_yu9v8f(tmp, tmp$ret$1);
+      }
+      es(other) {
+        var s = this.bs_1.g5(other.bs_1);
+        if (!(s === 0)) {
+          return s;
+        }
+        return compareTo(this.cs_1, other.cs_1);
+      }
+      d(other) {
+        return this.es(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 = equalsLong(this.bs_1, other.bs_1);
+          } else {
+            tmp_1 = false;
+          }
+          if (tmp_1) {
+            tmp_0 = this.cs_1 === other.cs_1;
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return this.bs_1.hashCode() + imul(51, this.cs_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().m1();
+  var ldt = Companion_instance_0.fs(instant);
+  var number = ldt.gs_1;
+  // Inline function 'kotlin.math.absoluteValue' call
+  if (abs(number) < 1000) {
+    var innerBuilder = StringBuilder().m1();
+    if (number >= 0) {
+      // Inline function 'kotlin.text.deleteAt' call
+      innerBuilder.dh(number + 10000 | 0).ih(0);
+    } else {
+      // Inline function 'kotlin.text.deleteAt' call
+      innerBuilder.dh(number - 10000 | 0).ih(1);
+    }
+    this_0.s2(innerBuilder);
+  } else {
+    if (number >= 10000) {
+      this_0.p1(_Char___init__impl__6a9atx(43));
+    }
+    this_0.dh(number);
+  }
+  this_0.p1(_Char___init__impl__6a9atx(45));
+  formatIso$appendTwoDigits(this_0, this_0, ldt.hs_1);
+  this_0.p1(_Char___init__impl__6a9atx(45));
+  formatIso$appendTwoDigits(this_0, this_0, ldt.is_1);
+  this_0.p1(_Char___init__impl__6a9atx(84));
+  formatIso$appendTwoDigits(this_0, this_0, ldt.js_1);
+  this_0.p1(_Char___init__impl__6a9atx(58));
+  formatIso$appendTwoDigits(this_0, this_0, ldt.ks_1);
+  this_0.p1(_Char___init__impl__6a9atx(58));
+  formatIso$appendTwoDigits(this_0, this_0, ldt.ls_1);
+  if (!(ldt.ms_1 === 0)) {
+    this_0.p1(_Char___init__impl__6a9atx(46));
+    var zerosToStrip = 0;
+    while ((ldt.ms_1 % get_POWERS_OF_TEN()[zerosToStrip + 1 | 0] | 0) === 0) {
+      zerosToStrip = zerosToStrip + 1 | 0;
+    }
+    zerosToStrip = zerosToStrip - (zerosToStrip % 3 | 0) | 0;
+    var numberToOutput = ldt.ms_1 / get_POWERS_OF_TEN()[zerosToStrip] | 0;
+    this_0.n1(substring((numberToOutput + get_POWERS_OF_TEN()[9 - zerosToStrip | 0] | 0).toString(), 1));
+  }
+  this_0.p1(_Char___init__impl__6a9atx(90));
+  return this_0.toString();
+}
+var SuccessClass;
+function Success() {
+  if (SuccessClass === VOID) {
+    class $ {
+      constructor(epochSeconds, nanosecondsOfSecond) {
+        this.ns_1 = epochSeconds;
+        this.os_1 = nanosecondsOfSecond;
+      }
+      as() {
+        if (compare(this.ns_1, Companion_getInstance_0().ij_1.bs_1) < 0 || compare(this.ns_1, Companion_getInstance_0().jj_1.bs_1) > 0)
+          throw InstantFormatException().ts('The parsed date is outside the range representable by Instant (Unix epoch second ' + this.ns_1.toString() + ')');
+        return Companion_getInstance_0().xr(this.ns_1, this.os_1);
+      }
+    }
+    initMetadataForClass($, 'Success');
+    SuccessClass = $;
+  }
+  return SuccessClass;
+}
+var FailureClass;
+function Failure() {
+  if (FailureClass === VOID) {
+    class $ {
+      constructor(error, input) {
+        this.us_1 = error;
+        this.vs_1 = input;
+      }
+      as() {
+        throw InstantFormatException().ts(this.us_1 + ' when parsing an Instant from "' + truncateForErrorMessage(this.vs_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.gs_1);
+  var total = multiply(numberToLong(365), y);
+  if (compare(y, new (Long())(0, 0)) >= 0) {
+    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.hs_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.is_1 - 1 | 0;
+  total = add(tmp0_0, fromInt(other_0));
+  if (this_0.hs_1 > 2) {
+    var _unary__edvuaz = total;
+    total = subtract(_unary__edvuaz, get_ONE());
+    if (!isLeapYear(this_0.gs_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.js_1, 3600) + imul(this_0.ks_1, 60) | 0) + this_0.ls_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.ms_1;
+  return new (Success())(epochSeconds, p1);
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {
+      fs(instant) {
+        var localSecond = instant.bs_1;
+        // Inline function 'kotlin.floorDiv' call
+        var other = new (Long())(86400, 0);
+        var q = divide(localSecond, other);
+        if (compare(bitwiseXor(localSecond, other), new (Long())(0, 0)) < 0 && !equalsLong(multiply(q, other), localSecond)) {
+          var _unary__edvuaz = q;
+          q = subtract(_unary__edvuaz, get_ONE());
+        }
+        var epochDays = q;
+        // Inline function 'kotlin.mod' call
+        var other_0 = new (Long())(86400, 0);
+        var r = modulo(localSecond, other_0);
+        var tmp$ret$1 = add(r, bitwiseAnd(other_0, shiftRight(bitwiseAnd(bitwiseXor(r, other_0), bitwiseOr(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 = new (Long())(0, 0);
+        if (compare(zeroDay, new (Long())(0, 0)) < 0) {
+          // 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 (compare(doyEst, new (Long())(0, 0)) < 0) {
+          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_1 = marchMonth0 / 10 | 0;
+        var tmp$ret$17 = add(tmp0, fromInt(other_1));
+        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.cs_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.gs_1 = year;
+        this.hs_1 = month;
+        this.is_1 = day;
+        this.js_1 = hour;
+        this.ks_1 = minute;
+        this.ls_1 = second;
+        this.ms_1 = nanosecond;
+      }
+      toString() {
+        return 'UnboundLocalDateTime(' + this.gs_1 + '-' + this.hs_1 + '-' + this.is_1 + ' ' + this.js_1 + ':' + this.ks_1 + ':' + this.ls_1 + '.' + this.ms_1 + ')';
+      }
+    }
+    initMetadataForClass($, 'UnboundLocalDateTime');
+    UnboundLocalDateTimeClass = $;
+  }
+  return UnboundLocalDateTimeClass;
+}
+var InstantFormatExceptionClass;
+function InstantFormatException() {
+  if (InstantFormatExceptionClass === VOID) {
+    class $ extends IllegalArgumentException() {
+      static ts(message) {
+        var $this = this.r2(message);
+        captureStack($this, $this.ss_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$appendTwoDigits(_this__u8e3s4, $this_buildString, number) {
+  if (number < 10) {
+    _this__u8e3s4.p1(_Char___init__impl__6a9atx(48));
+  }
+  $this_buildString.dh(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$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.x3_1;
+  return _Char___init__impl__6a9atx(48) <= containsArg ? containsArg <= _Char___init__impl__6a9atx(57) : false;
+}
+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;
+}
+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_getInstance229rema5imh9m,
+  Instant as Instant2s2zyzgfc4947,
+};
+//endregion
+
+//# sourceMappingURL=Instant.mjs.map