@attocash/commons-js 5.0.0

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/internal/format/parser/ParserOperation.mjs

@@ -0,0 +1,683 @@
+import {
+  mutableListOf6oorvk2mtdmp as mutableListOf,
+  listOf1jh22dvmctj1r as listOf,
+  emptyList1g2z5xcrvp2zy as emptyList,
+  binarySearchyyczvdessj07 as binarySearch,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { UnsignedIntConsumer25zhux255gkqb as UnsignedIntConsumer } from './NumberConsumer.mjs';
+import {
+  listOfvhqybd2zx248 as listOf_0,
+  checkCountOverflow1ro2fe1r4xvgf as checkCountOverflow,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import {
+  ParserStructure2cqp7gjft5io4 as ParserStructure,
+  concat2z827ubu7ap26 as concat,
+} from './Parser.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { repeat2w4c6j8zoq09o as repeat } from '../../../../../../kotlin-kotlin-stdlib/kotlin/text/stringsCode.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  hashCodeq5arwsb9dgti as hashCode,
+  toString1pkumu07cwy4m as toString,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { FunctionAdapter3lcrrz3moet5b as FunctionAdapter } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/FunctionAdapter.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { Comparator2b3maoeh98xtg as Comparator } from '../../../../../../kotlin-kotlin-stdlib/kotlin/ComparatorJs.mjs';
+import { to2cs3ny02qtbcb as to } from '../../../../../../kotlin-kotlin-stdlib/kotlin/Tuples.mjs';
+import {
+  singleo93pzdgfc557 as single,
+  sortedWith2csnbbb21k0lg as sortedWith,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { compareValues1n2ayl87ihzfk as compareValues } from '../../../../../../kotlin-kotlin-stdlib/kotlin/comparisons/Comparisons.mjs';
+import {
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charCodeAt1yspne1d8erbm as charCodeAt,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/charSequenceJs.mjs';
+import {
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  toString3o7ifthqydp6e as toString_0,
+  _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { startsWith641pyr7vf687 as startsWith } from '../../../../../../kotlin-kotlin-stdlib/kotlin/text/Strings.mjs';
+import { Companion_instance1vkshgwp6j1o1 as Companion_instance } from './ParseResult.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import { Collection1k04j3hzsbod0 as Collection } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs';
+import { isAsciiDigit3p3aq858xklh as isAsciiDigit } from '../../util.mjs';
+import { toString30pk9tzaqopn as toString_1 } from '../../../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function SignedIntParser(minDigits, maxDigits, spacePadding, setter, name, plusOnExceedsWidth) {
+  var parsers = mutableListOf([spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name, true)]);
+  if (!(plusOnExceedsWidth == null)) {
+    parsers.m(spaceAndZeroPaddedUnsignedInt(minDigits, plusOnExceedsWidth, spacePadding, setter, name));
+    parsers.m(new (ParserStructure())(listOf([new (PlainStringParserOperation())('+'), new (NumberSpanParserOperation())(listOf_0(new (UnsignedIntConsumer())(plusOnExceedsWidth + 1 | 0, maxDigits, setter, name, false)))]), emptyList()));
+  } else {
+    parsers.m(spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name));
+  }
+  return new (ParserStructure())(emptyList(), parsers);
+}
+function spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name, withMinus) {
+  withMinus = withMinus === VOID ? false : withMinus;
+  var minNumberLength = (minDigits == null ? 1 : minDigits) + (withMinus ? 1 : 0) | 0;
+  var tmp;
+  if (maxDigits == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    tmp = withMinus ? maxDigits + 1 | 0 : maxDigits;
+  }
+  var tmp2_elvis_lhs = tmp;
+  var maxNumberLength = tmp2_elvis_lhs == null ? 2147483647 : tmp2_elvis_lhs;
+  var spacePadding_0 = spacePadding == null ? 0 : spacePadding;
+  // Inline function 'kotlin.comparisons.minOf' call
+  var maxPaddedNumberLength = Math.min(maxNumberLength, spacePadding_0);
+  if (minNumberLength >= maxPaddedNumberLength)
+    return spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, minNumberLength, maxNumberLength);
+  var accumulated = spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, minNumberLength, minNumberLength);
+  var inductionVariable = minNumberLength;
+  if (inductionVariable < maxPaddedNumberLength)
+    do {
+      var accumulatedWidth = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      accumulated = new (ParserStructure())(emptyList(), listOf([spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, accumulatedWidth + 1 | 0, accumulatedWidth + 1 | 0), concat(listOf([new (ParserStructure())(listOf_0(new (PlainStringParserOperation())(' ')), emptyList()), accumulated]))]));
+    }
+     while (inductionVariable < maxPaddedNumberLength);
+  var tmp_0;
+  if (spacePadding_0 > maxNumberLength) {
+    var prepadding = new (PlainStringParserOperation())(repeat(' ', spacePadding_0 - maxNumberLength | 0));
+    tmp_0 = concat(listOf([new (ParserStructure())(listOf_0(prepadding), emptyList()), accumulated]));
+  } else if (spacePadding_0 === maxNumberLength) {
+    tmp_0 = accumulated;
+  } else {
+    var r = new (ParserStructure())(emptyList(), listOf([spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, spacePadding_0 + 1 | 0, maxNumberLength), accumulated]));
+    tmp_0 = r;
+  }
+  return tmp_0;
+}
+var TrieNodeClass;
+function TrieNode() {
+  if (TrieNodeClass === VOID) {
+    class $ {
+      constructor(children, isTerminal) {
+        var tmp;
+        if (children === VOID) {
+          // Inline function 'kotlin.collections.mutableListOf' call
+          tmp = ArrayList().l1();
+        } else {
+          tmp = children;
+        }
+        children = tmp;
+        isTerminal = isTerminal === VOID ? false : isTerminal;
+        this.i1u_1 = children;
+        this.j1u_1 = isTerminal;
+      }
+    }
+    initMetadataForClass($, 'TrieNode', TrieNode);
+    TrieNodeClass = $;
+  }
+  return TrieNodeClass;
+}
+var sam$kotlin_Comparator$0Class;
+function sam$kotlin_Comparator$0() {
+  if (sam$kotlin_Comparator$0Class === VOID) {
+    class $ {
+      constructor(function_0) {
+        this.k1u_1 = function_0;
+      }
+      wi(a, b) {
+        return this.k1u_1(a, b);
+      }
+      compare(a, b) {
+        return this.wi(a, b);
+      }
+      i4() {
+        return this.k1u_1;
+      }
+      equals(other) {
+        var tmp;
+        if (!(other == null) ? isInterface(other, Comparator()) : false) {
+          var tmp_0;
+          if (!(other == null) ? isInterface(other, FunctionAdapter()) : false) {
+            tmp_0 = equals(this.i4(), other.i4());
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.i4());
+      }
+    }
+    initMetadataForClass($, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator(), FunctionAdapter()]);
+    sam$kotlin_Comparator$0Class = $;
+  }
+  return sam$kotlin_Comparator$0Class;
+}
+function _init_$reduceTrie(trie) {
+  var tmp0_iterator = trie.i1u_1.d1();
+  while (tmp0_iterator.e1()) {
+    var child = tmp0_iterator.f1().hl();
+    _init_$reduceTrie(child);
+  }
+  // Inline function 'kotlin.collections.mutableListOf' call
+  var newChildren = ArrayList().l1();
+  var tmp2_iterator = trie.i1u_1.d1();
+  while (tmp2_iterator.e1()) {
+    var tmp3_loop_parameter = tmp2_iterator.f1();
+    var key = tmp3_loop_parameter.gl();
+    var child_0 = tmp3_loop_parameter.hl();
+    if (!child_0.j1u_1 && child_0.i1u_1.i1() === 1) {
+      var tmp4_container = single(child_0.i1u_1);
+      var grandChildKey = tmp4_container.gl();
+      var grandChild = tmp4_container.hl();
+      newChildren.m(to(key + grandChildKey, grandChild));
+    } else {
+      newChildren.m(to(key, child_0));
+    }
+  }
+  trie.i1u_1.z2();
+  // Inline function 'kotlin.collections.sortedBy' call
+  // Inline function 'kotlin.comparisons.compareBy' call
+  var tmp = StringSetParserOperation$reduceTrie$lambda;
+  var tmp$ret$1 = new (sam$kotlin_Comparator$0())(tmp);
+  var tmp$ret$2 = sortedWith(newChildren, tmp$ret$1);
+  trie.i1u_1.k1(tmp$ret$2);
+}
+function StringSetParserOperation$lambda($key) {
+  return function (it) {
+    var tmp$ret$0 = it.el_1;
+    return compareValues(tmp$ret$0, $key);
+  };
+}
+function StringSetParserOperation$consume$lambda(this$0, $input, $startIndex, $index) {
+  return function () {
+    var tmp0 = $input;
+    var tmp2 = $startIndex;
+    // Inline function 'kotlin.text.substring' call
+    var endIndex = $index._v;
+    var tmp$ret$0 = toString(charSequenceSubSequence(tmp0, tmp2, endIndex));
+    return 'Expected ' + this$0.m1u_1 + ' but got ' + tmp$ret$0;
+  };
+}
+function StringSetParserOperation$reduceTrie$lambda(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  var tmp = a.el_1;
+  var tmp$ret$1 = b.el_1;
+  return compareValues(tmp, tmp$ret$1);
+}
+var StringSetParserOperationClass;
+function StringSetParserOperation() {
+  if (StringSetParserOperationClass === VOID) {
+    class $ {
+      constructor(strings, setter, whatThisExpects) {
+        this.l1u_1 = setter;
+        this.m1u_1 = whatThisExpects;
+        this.n1u_1 = new (TrieNode())();
+        var tmp0_iterator = strings.d1();
+        while (tmp0_iterator.e1()) {
+          var string = tmp0_iterator.f1();
+          // Inline function 'kotlin.text.isNotEmpty' call
+          // Inline function 'kotlin.require' call
+          if (!(charSequenceLength(string) > 0)) {
+            var message = 'Found an empty string in ' + this.m1u_1;
+            throw IllegalArgumentException().u(toString(message));
+          }
+          var node = this.n1u_1;
+          var inductionVariable = 0;
+          var last = string.length;
+          while (inductionVariable < last) {
+            var char = charCodeAt(string, inductionVariable);
+            inductionVariable = inductionVariable + 1 | 0;
+            var tmp0 = node.i1u_1;
+            // Inline function 'kotlin.collections.binarySearchBy' call
+            var key = toString_0(char);
+            var toIndex = tmp0.i1();
+            var searchResult = binarySearch(tmp0, 0, toIndex, StringSetParserOperation$lambda(key));
+            var tmp;
+            if (searchResult < 0) {
+              // Inline function 'kotlin.also' call
+              var this_0 = new (TrieNode())();
+              node.i1u_1.b3((-searchResult | 0) - 1 | 0, to(toString_0(char), this_0));
+              tmp = this_0;
+            } else {
+              tmp = node.i1u_1.j1(searchResult).fl_1;
+            }
+            node = tmp;
+          }
+          // Inline function 'kotlin.require' call
+          if (!!node.j1u_1) {
+            var message_0 = "The string '" + string + "' was passed several times";
+            throw IllegalArgumentException().u(toString(message_0));
+          }
+          node.j1u_1 = true;
+        }
+        _init_$reduceTrie(this.n1u_1);
+      }
+      z1t(storage, input, startIndex) {
+        var node = this.n1u_1;
+        var index = {_v: startIndex};
+        var lastMatch = null;
+        loop: while (index._v <= charSequenceLength(input)) {
+          if (node.j1u_1)
+            lastMatch = index._v;
+          var tmp0_iterator = node.i1u_1.d1();
+          while (tmp0_iterator.e1()) {
+            var tmp1_loop_parameter = tmp0_iterator.f1();
+            var key = tmp1_loop_parameter.gl();
+            var child = tmp1_loop_parameter.hl();
+            if (startsWith(input, key, index._v)) {
+              node = child;
+              index._v = index._v + key.length | 0;
+              continue loop;
+            }
+          }
+          break loop;
+        }
+        var tmp;
+        if (!(lastMatch == null)) {
+          // Inline function 'kotlin.text.substring' call
+          var endIndex = lastMatch;
+          var tmp$ret$0 = toString(charSequenceSubSequence(input, startIndex, endIndex));
+          tmp = setWithoutReassigning(this.l1u_1, storage, tmp$ret$0, startIndex, lastMatch);
+        } else {
+          var tmp_0 = Companion_instance;
+          tmp = tmp_0.s1t(startIndex, StringSetParserOperation$consume$lambda(this, input, startIndex, index));
+        }
+        return tmp;
+      }
+    }
+    initMetadataForClass($, 'StringSetParserOperation');
+    StringSetParserOperationClass = $;
+  }
+  return StringSetParserOperationClass;
+}
+function _get_whatThisExpects__4pg11j($this) {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = $this.f1u_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList().c1(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.d1();
+  while (_iterator__ex2g4s.e1()) {
+    var item = _iterator__ex2g4s.f1();
+    var length = item.a();
+    var tmp$ret$0 = (length == null ? 'at least one digit' : '' + length + ' digits') + (' for ' + item.z1s_1);
+    destination.m(tmp$ret$0);
+  }
+  var consumerLengths = destination;
+  var tmp;
+  if ($this.h1u_1) {
+    tmp = 'a number with at least ' + $this.g1u_1 + ' digits: ' + toString(consumerLengths);
+  } else {
+    tmp = 'a number with exactly ' + $this.g1u_1 + ' digits: ' + toString(consumerLengths);
+  }
+  return tmp;
+}
+function NumberSpanParserOperation$consume$lambda(this$0) {
+  return function () {
+    return 'Unexpected end of input: yet to parse ' + _get_whatThisExpects__4pg11j(this$0);
+  };
+}
+function NumberSpanParserOperation$consume$lambda_0($digitsInRow, this$0) {
+  return function () {
+    return 'Only found ' + $digitsInRow._v + ' digits in a row, but need to parse ' + _get_whatThisExpects__4pg11j(this$0);
+  };
+}
+function NumberSpanParserOperation$consume$lambda_1($numberString, this$0, $i, $error) {
+  return function () {
+    return "Can not interpret the string '" + $numberString + "' as " + this$0.f1u_1.j1($i).z1s_1 + ': ' + $error.e1t();
+  };
+}
+var NumberSpanParserOperationClass;
+function NumberSpanParserOperation() {
+  if (NumberSpanParserOperationClass === VOID) {
+    class $ {
+      constructor(consumers) {
+        this.f1u_1 = consumers;
+        var tmp = this;
+        // Inline function 'kotlin.collections.sumOf' call
+        var sum = 0;
+        var _iterator__ex2g4s = this.f1u_1.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var element = _iterator__ex2g4s.f1();
+          var tmp_0 = sum;
+          var tmp0_elvis_lhs = element.a();
+          sum = tmp_0 + (tmp0_elvis_lhs == null ? 1 : tmp0_elvis_lhs) | 0;
+        }
+        tmp.g1u_1 = sum;
+        var tmp_1 = this;
+        var tmp0 = this.f1u_1;
+        var tmp$ret$2;
+        $l$block_0: {
+          // Inline function 'kotlin.collections.any' call
+          var tmp_2;
+          if (isInterface(tmp0, Collection())) {
+            tmp_2 = tmp0.j();
+          } else {
+            tmp_2 = false;
+          }
+          if (tmp_2) {
+            tmp$ret$2 = false;
+            break $l$block_0;
+          }
+          var _iterator__ex2g4s_0 = tmp0.d1();
+          while (_iterator__ex2g4s_0.e1()) {
+            var element_0 = _iterator__ex2g4s_0.f1();
+            if (element_0.a() == null) {
+              tmp$ret$2 = true;
+              break $l$block_0;
+            }
+          }
+          tmp$ret$2 = false;
+        }
+        tmp_1.h1u_1 = tmp$ret$2;
+        var tmp0_0 = this.f1u_1;
+        var tmp$ret$4;
+        $l$block_2: {
+          // Inline function 'kotlin.collections.all' call
+          var tmp_3;
+          if (isInterface(tmp0_0, Collection())) {
+            tmp_3 = tmp0_0.j();
+          } else {
+            tmp_3 = false;
+          }
+          if (tmp_3) {
+            tmp$ret$4 = true;
+            break $l$block_2;
+          }
+          var _iterator__ex2g4s_1 = tmp0_0.d1();
+          while (_iterator__ex2g4s_1.e1()) {
+            var element_1 = _iterator__ex2g4s_1.f1();
+            var tmp0_elvis_lhs_0 = element_1.a();
+            if (!((tmp0_elvis_lhs_0 == null ? 2147483647 : tmp0_elvis_lhs_0) > 0)) {
+              tmp$ret$4 = false;
+              break $l$block_2;
+            }
+          }
+          tmp$ret$4 = true;
+        }
+        // Inline function 'kotlin.require' call
+        // Inline function 'kotlin.require' call
+        if (!tmp$ret$4) {
+          var message = 'Failed requirement.';
+          throw IllegalArgumentException().u(toString(message));
+        }
+        var tmp0_1 = this.f1u_1;
+        var tmp$ret$9;
+        $l$block_3: {
+          // Inline function 'kotlin.collections.count' call
+          var tmp_4;
+          if (isInterface(tmp0_1, Collection())) {
+            tmp_4 = tmp0_1.j();
+          } else {
+            tmp_4 = false;
+          }
+          if (tmp_4) {
+            tmp$ret$9 = 0;
+            break $l$block_3;
+          }
+          var count = 0;
+          var _iterator__ex2g4s_2 = tmp0_1.d1();
+          while (_iterator__ex2g4s_2.e1()) {
+            var element_2 = _iterator__ex2g4s_2.f1();
+            if (element_2.a() == null) {
+              count = count + 1 | 0;
+              checkCountOverflow(count);
+            }
+          }
+          tmp$ret$9 = count;
+        }
+        // Inline function 'kotlin.require' call
+        if (!(tmp$ret$9 <= 1)) {
+          // Inline function 'kotlin.collections.filter' call
+          var tmp0_2 = this.f1u_1;
+          // Inline function 'kotlin.collections.filterTo' call
+          var destination = ArrayList().l1();
+          var _iterator__ex2g4s_3 = tmp0_2.d1();
+          while (_iterator__ex2g4s_3.e1()) {
+            var element_3 = _iterator__ex2g4s_3.f1();
+            if (element_3.a() == null) {
+              destination.m(element_3);
+            }
+          }
+          // Inline function 'kotlin.collections.map' call
+          // Inline function 'kotlin.collections.mapTo' call
+          var destination_0 = ArrayList().c1(collectionSizeOrDefault(destination, 10));
+          var _iterator__ex2g4s_4 = destination.d1();
+          while (_iterator__ex2g4s_4.e1()) {
+            var item = _iterator__ex2g4s_4.f1();
+            var tmp$ret$14 = item.z1s_1;
+            destination_0.m(tmp$ret$14);
+          }
+          var fieldNames = destination_0;
+          var message_0 = 'At most one variable-length numeric field in a row is allowed, but got several: ' + toString(fieldNames) + '. ' + 'Parsing is undefined: for example, with variable-length month number ' + "and variable-length day of month, '111' can be parsed as Jan 11th or Nov 1st.";
+          throw IllegalArgumentException().u(toString(message_0));
+        }
+      }
+      z1t(storage, input, startIndex) {
+        if ((startIndex + this.g1u_1 | 0) > charSequenceLength(input)) {
+          var tmp = Companion_instance;
+          return tmp.s1t(startIndex, NumberSpanParserOperation$consume$lambda(this));
+        }
+        var digitsInRow = {_v: 0};
+        while ((startIndex + digitsInRow._v | 0) < charSequenceLength(input) && isAsciiDigit(charSequenceGet(input, startIndex + digitsInRow._v | 0))) {
+          digitsInRow._v = digitsInRow._v + 1 | 0;
+          digitsInRow._v;
+        }
+        if (digitsInRow._v < this.g1u_1) {
+          var tmp_0 = Companion_instance;
+          return tmp_0.s1t(startIndex, NumberSpanParserOperation$consume$lambda_0(digitsInRow, this));
+        }
+        var index = startIndex;
+        var inductionVariable = 0;
+        var last = this.f1u_1.i1() - 1 | 0;
+        if (inductionVariable <= last)
+          do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var tmp1_elvis_lhs = this.f1u_1.j1(i).a();
+            var length = tmp1_elvis_lhs == null ? (digitsInRow._v - this.g1u_1 | 0) + 1 | 0 : tmp1_elvis_lhs;
+            var error = this.f1u_1.j1(i).a1t(storage, input, index, index + length | 0);
+            if (!(error == null)) {
+              var tmp2 = index;
+              // Inline function 'kotlin.text.substring' call
+              var endIndex = index + length | 0;
+              var numberString = toString(charSequenceSubSequence(input, tmp2, endIndex));
+              var tmp_1 = Companion_instance;
+              var tmp_2 = index;
+              return tmp_1.s1t(tmp_2, NumberSpanParserOperation$consume$lambda_1(numberString, this, i, error));
+            }
+            index = index + length | 0;
+          }
+           while (inductionVariable <= last);
+        return Companion_instance.r1t(index);
+      }
+      toString() {
+        return _get_whatThisExpects__4pg11j(this);
+      }
+    }
+    initMetadataForClass($, 'NumberSpanParserOperation');
+    NumberSpanParserOperationClass = $;
+  }
+  return NumberSpanParserOperationClass;
+}
+function PlainStringParserOperation$consume$lambda(this$0) {
+  return function () {
+    return "Unexpected end of input: yet to parse '" + this$0.o1u_1 + "'";
+  };
+}
+function PlainStringParserOperation$consume$lambda_0(this$0, $input, $startIndex, $i) {
+  return function () {
+    var tmp0 = $input;
+    var tmp2 = $startIndex;
+    // Inline function 'kotlin.text.substring' call
+    var endIndex = ($startIndex + $i | 0) + 1 | 0;
+    var tmp$ret$0 = toString(charSequenceSubSequence(tmp0, tmp2, endIndex));
+    return 'Expected ' + this$0.o1u_1 + ' but got ' + tmp$ret$0;
+  };
+}
+var PlainStringParserOperationClass;
+function PlainStringParserOperation() {
+  if (PlainStringParserOperationClass === VOID) {
+    class $ {
+      constructor(string) {
+        this.o1u_1 = string;
+        // Inline function 'kotlin.text.isNotEmpty' call
+        var this_0 = this.o1u_1;
+        // Inline function 'kotlin.require' call
+        if (!(charSequenceLength(this_0) > 0)) {
+          var message = 'Empty string is not allowed';
+          throw IllegalArgumentException().u(toString(message));
+        }
+        // Inline function 'kotlin.require' call
+        if (!!isAsciiDigit(charCodeAt(this.o1u_1, 0))) {
+          var message_0 = "String '" + this.o1u_1 + "' starts with a digit";
+          throw IllegalArgumentException().u(toString(message_0));
+        }
+        // Inline function 'kotlin.require' call
+        if (!!isAsciiDigit(charCodeAt(this.o1u_1, this.o1u_1.length - 1 | 0))) {
+          var message_1 = "String '" + this.o1u_1 + "' ends with a digit";
+          throw IllegalArgumentException().u(toString(message_1));
+        }
+      }
+      z1t(storage, input, startIndex) {
+        if ((startIndex + this.o1u_1.length | 0) > charSequenceLength(input)) {
+          var tmp = Companion_instance;
+          return tmp.s1t(startIndex, PlainStringParserOperation$consume$lambda(this));
+        }
+        var inductionVariable = 0;
+        var last = charSequenceLength(this.o1u_1) - 1 | 0;
+        if (inductionVariable <= last)
+          do {
+            var i = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            if (!(charSequenceGet(input, startIndex + i | 0) === charCodeAt(this.o1u_1, i))) {
+              var tmp_0 = Companion_instance;
+              return tmp_0.s1t(startIndex, PlainStringParserOperation$consume$lambda_0(this, input, startIndex, i));
+            }
+          }
+           while (inductionVariable <= last);
+        return Companion_instance.r1t(startIndex + this.o1u_1.length | 0);
+      }
+      toString() {
+        return "'" + this.o1u_1 + "'";
+      }
+    }
+    initMetadataForClass($, 'PlainStringParserOperation');
+    PlainStringParserOperationClass = $;
+  }
+  return PlainStringParserOperationClass;
+}
+function SignParser$consume$lambda(this$0, $char) {
+  return function () {
+    return 'Expected ' + this$0.r1u_1 + ' but got ' + toString_0($char);
+  };
+}
+var SignParserClass;
+function SignParser() {
+  if (SignParserClass === VOID) {
+    class $ {
+      constructor(isNegativeSetter, withPlusSign, whatThisExpects) {
+        this.p1u_1 = isNegativeSetter;
+        this.q1u_1 = withPlusSign;
+        this.r1u_1 = whatThisExpects;
+      }
+      z1t(storage, input, startIndex) {
+        if (startIndex >= charSequenceLength(input))
+          return Companion_instance.r1t(startIndex);
+        var char = charSequenceGet(input, startIndex);
+        if (char === _Char___init__impl__6a9atx(45)) {
+          this.p1u_1(storage, true);
+          return Companion_instance.r1t(startIndex + 1 | 0);
+        }
+        if (char === _Char___init__impl__6a9atx(43) && this.q1u_1) {
+          this.p1u_1(storage, false);
+          return Companion_instance.r1t(startIndex + 1 | 0);
+        }
+        var tmp = Companion_instance;
+        return tmp.s1t(startIndex, SignParser$consume$lambda(this, char));
+      }
+      toString() {
+        return this.r1u_1;
+      }
+    }
+    initMetadataForClass($, 'SignParser');
+    SignParserClass = $;
+  }
+  return SignParserClass;
+}
+var UnconditionalModificationClass;
+function UnconditionalModification() {
+  if (UnconditionalModificationClass === VOID) {
+    class $ {
+      constructor(operation) {
+        this.s1u_1 = operation;
+      }
+      z1t(storage, input, startIndex) {
+        this.s1u_1(storage);
+        return Companion_instance.r1t(startIndex);
+      }
+    }
+    initMetadataForClass($, 'UnconditionalModification');
+    UnconditionalModificationClass = $;
+  }
+  return UnconditionalModificationClass;
+}
+function setWithoutReassigning(_this__u8e3s4, receiver, value, position, nextIndex) {
+  var conflictingValue = _this__u8e3s4.z1q(receiver, value);
+  var tmp;
+  if (conflictingValue === null) {
+    tmp = Companion_instance.r1t(nextIndex);
+  } else {
+    var tmp_0 = Companion_instance;
+    tmp = tmp_0.s1t(position, setWithoutReassigning$lambda(conflictingValue, value, _this__u8e3s4));
+  }
+  return tmp;
+}
+function spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths($withMinus, $setter, $name, minNumberLength, maxNumberLength) {
+  // Inline function 'kotlin.check' call
+  if (!(maxNumberLength >= (1 + ($withMinus ? 1 : 0) | 0))) {
+    throw IllegalStateException().o4('Check failed.');
+  }
+  // Inline function 'kotlin.collections.buildList' call
+  // Inline function 'kotlin.collections.buildListInternal' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = ArrayList().l1();
+  if ($withMinus) {
+    this_0.m(new (PlainStringParserOperation())('-'));
+  }
+  this_0.m(new (NumberSpanParserOperation())(listOf_0(new (UnsignedIntConsumer())(minNumberLength - ($withMinus ? 1 : 0) | 0, maxNumberLength - ($withMinus ? 1 : 0) | 0, $setter, $name, $withMinus))));
+  var tmp$ret$4 = this_0.p7();
+  return new (ParserStructure())(tmp$ret$4, emptyList());
+}
+function setWithoutReassigning$lambda($conflictingValue, $value, $this_setWithoutReassigning) {
+  return function () {
+    return "Attempting to assign conflicting values '" + toString_1($conflictingValue) + "' and '" + toString_1($value) + "' to field '" + $this_setWithoutReassigning.i3() + "'";
+  };
+}
+//region block: exports
+export {
+  NumberSpanParserOperation as NumberSpanParserOperation3qyp02c4km7yu,
+  PlainStringParserOperation as PlainStringParserOperation3o6zmwb0f0e6n,
+  SignParser as SignParserj94qlnys16wg,
+  SignedIntParser as SignedIntParsergn6823y2nf4q,
+  StringSetParserOperation as StringSetParserOperation82b6pl2fn98q,
+  UnconditionalModification as UnconditionalModification151pp4lqfue9i,
+  spaceAndZeroPaddedUnsignedInt as spaceAndZeroPaddedUnsignedInt3iec50j4qusnr,
+};
+//endregion
+
+//# sourceMappingURL=ParserOperation.mjs.map