@attocash/commons-js 6.2.1 → 6.3.0

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/internal/format/formatter/Formatter.mjs

@@ -21,10 +21,10 @@ function format$default(obj, builder, minusNotRequired, $super) {
   minusNotRequired = minusNotRequired === VOID ? false : minusNotRequired;
   var tmp;
   if ($super === VOID) {
-    this.h2n(obj, builder, minusNotRequired);
+    this.k2n(obj, builder, minusNotRequired);
     tmp = Unit_instance;
   } else {
-    tmp = $super.h2n.call(this, obj, builder, minusNotRequired);
+    tmp = $super.k2n.call(this, obj, builder, minusNotRequired);
   }
   return tmp;
 }
@@ -42,16 +42,16 @@ function SpacePaddedFormatter() {
   if (SpacePaddedFormatterClass === VOID) {
     class $ {
       constructor(formatter, padding) {
-        this.i2n_1 = formatter;
-        this.j2n_1 = padding;
+        this.l2n_1 = formatter;
+        this.m2n_1 = padding;
       }
-      h2n(obj, builder, minusNotRequired) {
+      k2n(obj, builder, minusNotRequired) {
         // Inline function 'kotlin.let' call
         var it = StringBuilder().m1();
-        this.i2n_1.h2n(obj, it, minusNotRequired);
+        this.l2n_1.k2n(obj, it, minusNotRequired);
         var string = it.toString();
         // Inline function 'kotlin.repeat' call
-        var times = this.j2n_1 - string.length | 0;
+        var times = this.m2n_1 - string.length | 0;
         var inductionVariable = 0;
         if (inductionVariable < times)
           do {
@@ -60,10 +60,10 @@ function SpacePaddedFormatter() {
             builder.p1(_Char___init__impl__6a9atx(32));
           }
            while (inductionVariable < times);
-        builder.l2(string);
+        builder.j2(string);
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'SpacePaddedFormatter', VOID, VOID, [FormatterStructure()]);
     SpacePaddedFormatterClass = $;
   }
@@ -74,15 +74,15 @@ function SignedFormatter() {
   if (SignedFormatterClass === VOID) {
     class $ {
       constructor(formatter, allSubFormatsNegative, alwaysOutputSign) {
-        this.k2n_1 = formatter;
-        this.l2n_1 = allSubFormatsNegative;
-        this.m2n_1 = alwaysOutputSign;
+        this.n2n_1 = formatter;
+        this.o2n_1 = allSubFormatsNegative;
+        this.p2n_1 = alwaysOutputSign;
       }
-      h2n(obj, builder, minusNotRequired) {
+      k2n(obj, builder, minusNotRequired) {
         var tmp;
-        if (!minusNotRequired && this.l2n_1(obj)) {
+        if (!minusNotRequired && this.o2n_1(obj)) {
           tmp = _Char___init__impl__6a9atx(45);
-        } else if (this.m2n_1) {
+        } else if (this.p2n_1) {
           tmp = _Char___init__impl__6a9atx(43);
         } else {
           tmp = null;
@@ -104,10 +104,10 @@ function SignedFormatter() {
           var tmp_3 = sign;
           tmp_2 = equals(tmp_3 == null ? null : new (Char())(tmp_3), new (Char())(_Char___init__impl__6a9atx(45)));
         }
-        this.k2n_1.h2n(obj, builder, tmp_2);
+        this.n2n_1.k2n(obj, builder, tmp_2);
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'SignedFormatter', VOID, VOID, [FormatterStructure()]);
     SignedFormatterClass = $;
   }
@@ -118,22 +118,22 @@ function ConditionalFormatter() {
   if (ConditionalFormatterClass === VOID) {
     class $ {
       constructor(formatters) {
-        this.n2n_1 = formatters;
+        this.q2n_1 = formatters;
       }
-      h2n(obj, builder, minusNotRequired) {
-        var _iterator__ex2g4s = this.n2n_1.q1();
+      k2n(obj, builder, minusNotRequired) {
+        var _iterator__ex2g4s = this.q2n_1.q1();
         while (_iterator__ex2g4s.r1()) {
           var _destruct__k2r9zo = _iterator__ex2g4s.s1();
-          var condition = _destruct__k2r9zo.ef();
-          var formatter = _destruct__k2r9zo.ff();
+          var condition = _destruct__k2r9zo.hf();
+          var formatter = _destruct__k2r9zo.if();
           if (condition(obj)) {
-            formatter.h2n(obj, builder, minusNotRequired);
+            formatter.k2n(obj, builder, minusNotRequired);
             return Unit_instance;
           }
         }
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'ConditionalFormatter', VOID, VOID, [FormatterStructure()]);
     ConditionalFormatterClass = $;
   }
@@ -144,17 +144,17 @@ function ConcatenatedFormatter() {
   if (ConcatenatedFormatterClass === VOID) {
     class $ {
       constructor(formatters) {
-        this.o2n_1 = formatters;
+        this.r2n_1 = formatters;
       }
-      h2n(obj, builder, minusNotRequired) {
-        var _iterator__ex2g4s = this.o2n_1.q1();
+      k2n(obj, builder, minusNotRequired) {
+        var _iterator__ex2g4s = this.r2n_1.q1();
         while (_iterator__ex2g4s.r1()) {
           var formatter = _iterator__ex2g4s.s1();
-          formatter.h2n(obj, builder, minusNotRequired);
+          formatter.k2n(obj, builder, minusNotRequired);
         }
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'ConcatenatedFormatter', VOID, VOID, [FormatterStructure()]);
     ConcatenatedFormatterClass = $;
   }

package/Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/internal/format/formatter/FormatterOperation.mjs

@@ -24,24 +24,24 @@ function UnsignedIntFormatterStructure() {
   if (UnsignedIntFormatterStructureClass === VOID) {
     class $ {
       constructor(number, zeroPadding) {
-        this.p2n_1 = number;
-        this.q2n_1 = zeroPadding;
+        this.s2n_1 = number;
+        this.t2n_1 = zeroPadding;
         // Inline function 'kotlin.require' call
-        if (!(this.q2n_1 >= 0)) {
-          var message = 'The minimum number of digits (' + this.q2n_1 + ') is negative';
+        if (!(this.t2n_1 >= 0)) {
+          var message = 'The minimum number of digits (' + this.t2n_1 + ') is negative';
           throw IllegalArgumentException().t2(toString(message));
         }
         // Inline function 'kotlin.require' call
-        if (!(this.q2n_1 <= 9)) {
-          var message_0 = 'The minimum number of digits (' + this.q2n_1 + ') exceeds the length of an Int';
+        if (!(this.t2n_1 <= 9)) {
+          var message_0 = 'The minimum number of digits (' + this.t2n_1 + ') exceeds the length of an Int';
           throw IllegalArgumentException().t2(toString(message_0));
         }
       }
-      h2n(obj, builder, minusNotRequired) {
-        var num = this.p2n_1(obj);
+      k2n(obj, builder, minusNotRequired) {
+        var num = this.s2n_1(obj);
         var numberStr = num.toString();
         // Inline function 'kotlin.repeat' call
-        var times = this.q2n_1 - numberStr.length | 0;
+        var times = this.t2n_1 - numberStr.length | 0;
         var inductionVariable = 0;
         if (inductionVariable < times)
           do {
@@ -50,10 +50,10 @@ function UnsignedIntFormatterStructure() {
             builder.p1(_Char___init__impl__6a9atx(48));
           }
            while (inductionVariable < times);
-        builder.l2(numberStr);
+        builder.j2(numberStr);
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'UnsignedIntFormatterStructure', VOID, VOID, [FormatterStructure()]);
     UnsignedIntFormatterStructureClass = $;
   }
@@ -64,40 +64,40 @@ function DecimalFractionFormatterStructure() {
   if (DecimalFractionFormatterStructureClass === VOID) {
     class $ {
       constructor(number, minDigits, maxDigits, zerosToAdd) {
-        this.r2n_1 = number;
-        this.s2n_1 = minDigits;
-        this.t2n_1 = maxDigits;
-        this.u2n_1 = zerosToAdd;
-        var containsArg = this.s2n_1;
+        this.u2n_1 = number;
+        this.v2n_1 = minDigits;
+        this.w2n_1 = maxDigits;
+        this.x2n_1 = zerosToAdd;
+        var containsArg = this.v2n_1;
         // Inline function 'kotlin.require' call
         if (!(1 <= containsArg ? containsArg <= 9 : false)) {
-          var message = 'The minimum number of digits (' + this.s2n_1 + ') is not in range 1..9';
+          var message = 'The minimum number of digits (' + this.v2n_1 + ') is not in range 1..9';
           throw IllegalArgumentException().t2(toString(message));
         }
-        var containsLower = this.s2n_1;
-        var containsArg_0 = this.t2n_1;
+        var containsLower = this.v2n_1;
+        var containsArg_0 = this.w2n_1;
         // Inline function 'kotlin.require' call
         if (!(containsLower <= containsArg_0 ? containsArg_0 <= 9 : false)) {
-          var message_0 = 'The maximum number of digits (' + this.t2n_1 + ') is not in range ' + this.s2n_1 + '..9';
+          var message_0 = 'The maximum number of digits (' + this.w2n_1 + ') is not in range ' + this.v2n_1 + '..9';
           throw IllegalArgumentException().t2(toString(message_0));
         }
       }
-      h2n(obj, builder, minusNotRequired) {
-        var number = this.r2n_1(obj);
-        var numberWithRequiredPrecision = number.k2h(this.t2n_1);
+      k2n(obj, builder, minusNotRequired) {
+        var number = this.u2n_1(obj);
+        var numberWithRequiredPrecision = number.n2h(this.w2n_1);
         var zerosToStrip = 0;
-        while (this.t2n_1 > (this.s2n_1 + zerosToStrip | 0) && (numberWithRequiredPrecision % get_POWERS_OF_TEN()[zerosToStrip + 1 | 0] | 0) === 0) {
+        while (this.w2n_1 > (this.v2n_1 + zerosToStrip | 0) && (numberWithRequiredPrecision % get_POWERS_OF_TEN()[zerosToStrip + 1 | 0] | 0) === 0) {
           zerosToStrip = zerosToStrip + 1 | 0;
         }
-        var zerosToAddBack = this.u2n_1.v2((this.t2n_1 - zerosToStrip | 0) - 1 | 0);
+        var zerosToAddBack = this.x2n_1.v2((this.w2n_1 - zerosToStrip | 0) - 1 | 0);
         if (zerosToStrip >= zerosToAddBack)
           zerosToStrip = zerosToStrip - zerosToAddBack | 0;
-        var digitsToOutput = this.t2n_1 - zerosToStrip | 0;
+        var digitsToOutput = this.w2n_1 - zerosToStrip | 0;
         var numberToOutput = numberWithRequiredPrecision / get_POWERS_OF_TEN()[zerosToStrip] | 0;
-        builder.l2(substring((numberToOutput + get_POWERS_OF_TEN()[digitsToOutput] | 0).toString(), 1));
+        builder.j2(substring((numberToOutput + get_POWERS_OF_TEN()[digitsToOutput] | 0).toString(), 1));
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'DecimalFractionFormatterStructure', VOID, VOID, [FormatterStructure()]);
     DecimalFractionFormatterStructureClass = $;
   }
@@ -108,42 +108,42 @@ function SignedIntFormatterStructure() {
   if (SignedIntFormatterStructureClass === VOID) {
     class $ {
       constructor(number, zeroPadding, outputPlusOnExceededWidth) {
-        this.v2n_1 = number;
-        this.w2n_1 = zeroPadding;
-        this.x2n_1 = outputPlusOnExceededWidth;
+        this.y2n_1 = number;
+        this.z2n_1 = zeroPadding;
+        this.a2o_1 = outputPlusOnExceededWidth;
         // Inline function 'kotlin.require' call
-        if (!(this.w2n_1 >= 0)) {
-          var message = 'The minimum number of digits (' + this.w2n_1 + ') is negative';
+        if (!(this.z2n_1 >= 0)) {
+          var message = 'The minimum number of digits (' + this.z2n_1 + ') is negative';
           throw IllegalArgumentException().t2(toString(message));
         }
         // Inline function 'kotlin.require' call
-        if (!(this.w2n_1 <= 9)) {
-          var message_0 = 'The minimum number of digits (' + this.w2n_1 + ') exceeds the length of an Int';
+        if (!(this.z2n_1 <= 9)) {
+          var message_0 = 'The minimum number of digits (' + this.z2n_1 + ') exceeds the length of an Int';
           throw IllegalArgumentException().t2(toString(message_0));
         }
       }
-      h2n(obj, builder, minusNotRequired) {
+      k2n(obj, builder, minusNotRequired) {
         var innerBuilder = StringBuilder().m1();
         // Inline function 'kotlin.let' call
-        var it = this.v2n_1(obj);
+        var it = this.y2n_1(obj);
         var number = minusNotRequired && it < 0 ? -it | 0 : it;
-        if (!(this.x2n_1 == null) && number >= get_POWERS_OF_TEN()[this.x2n_1]) {
+        if (!(this.a2o_1 == null) && number >= get_POWERS_OF_TEN()[this.a2o_1]) {
           innerBuilder.p1(_Char___init__impl__6a9atx(43));
         }
         // Inline function 'kotlin.math.absoluteValue' call
-        if (abs(number) < get_POWERS_OF_TEN()[this.w2n_1 - 1 | 0]) {
+        if (abs(number) < get_POWERS_OF_TEN()[this.z2n_1 - 1 | 0]) {
           if (number >= 0) {
-            innerBuilder.yg(number + get_POWERS_OF_TEN()[this.w2n_1] | 0).dh(0);
+            innerBuilder.bh(number + get_POWERS_OF_TEN()[this.z2n_1] | 0).gh(0);
           } else {
-            innerBuilder.yg(number - get_POWERS_OF_TEN()[this.w2n_1] | 0).dh(1);
+            innerBuilder.bh(number - get_POWERS_OF_TEN()[this.z2n_1] | 0).gh(1);
           }
         } else {
-          innerBuilder.yg(number);
+          innerBuilder.bh(number);
         }
-        builder.l2(innerBuilder);
+        builder.j2(innerBuilder);
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'SignedIntFormatterStructure', VOID, VOID, [FormatterStructure()]);
     SignedIntFormatterStructureClass = $;
   }
@@ -154,13 +154,13 @@ function ConstantStringFormatterStructure() {
   if (ConstantStringFormatterStructureClass === VOID) {
     class $ {
       constructor(string) {
-        this.y2n_1 = string;
+        this.b2o_1 = string;
       }
-      h2n(obj, builder, minusNotRequired) {
-        builder.l2(this.y2n_1);
+      k2n(obj, builder, minusNotRequired) {
+        builder.j2(this.b2o_1);
       }
     }
-    protoOf($).d2d = format$default;
+    protoOf($).g2d = format$default;
     initMetadataForClass($, 'ConstantStringFormatterStructure', VOID, VOID, [FormatterStructure()]);
     ConstantStringFormatterStructureClass = $;
   }

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

@@ -24,25 +24,25 @@ function FractionPartConsumer() {
     class $ extends NumberConsumer() {
       constructor(minLength, maxLength, setter, name) {
         super(minLength === maxLength ? minLength : null, name);
-        this.b2o_1 = minLength;
-        this.c2o_1 = maxLength;
-        this.d2o_1 = setter;
-        var containsArg = this.b2o_1;
+        this.e2o_1 = minLength;
+        this.f2o_1 = maxLength;
+        this.g2o_1 = setter;
+        var containsArg = this.e2o_1;
         // Inline function 'kotlin.require' call
         if (!(1 <= containsArg ? containsArg <= 9 : false)) {
-          var message = 'Invalid minimum length ' + this.b2o_1 + ' for field ' + this.f2o_1 + ': expected 1..9';
+          var message = 'Invalid minimum length ' + this.e2o_1 + ' for field ' + this.i2o_1 + ': expected 1..9';
           throw IllegalArgumentException().t2(toString(message));
         }
-        var containsLower = this.b2o_1;
-        var containsArg_0 = this.c2o_1;
+        var containsLower = this.e2o_1;
+        var containsArg_0 = this.f2o_1;
         // Inline function 'kotlin.require' call
         if (!(containsLower <= containsArg_0 ? containsArg_0 <= 9 : false)) {
-          var message_0 = 'Invalid maximum length ' + this.c2o_1 + ' for field ' + this.f2o_1 + ': expected ' + this.b2o_1 + '..9';
+          var message_0 = 'Invalid maximum length ' + this.f2o_1 + ' for field ' + this.i2o_1 + ': expected ' + this.e2o_1 + '..9';
           throw IllegalArgumentException().t2(toString(message_0));
         }
       }
-      g2o(storage, input, start, end) {
-        return (end - start | 0) < this.b2o_1 ? new (TooFewDigits())(this.b2o_1) : (end - start | 0) > this.c2o_1 ? new (TooManyDigits())(this.c2o_1) : setWithoutReassigning(this.d2o_1, storage, new (DecimalFraction())(parseAsciiInt(input, start, end), end - start | 0));
+      j2o(storage, input, start, end) {
+        return (end - start | 0) < this.e2o_1 ? new (TooFewDigits())(this.e2o_1) : (end - start | 0) > this.f2o_1 ? new (TooManyDigits())(this.f2o_1) : setWithoutReassigning(this.g2o_1, storage, new (DecimalFraction())(parseAsciiInt(input, start, end), end - start | 0));
       }
     }
     initMetadataForClass($, 'FractionPartConsumer');
@@ -56,15 +56,15 @@ function ConstantNumberConsumer() {
     class $ extends NumberConsumer() {
       constructor(expected) {
         super(expected.length, 'the predefined string ' + expected);
-        this.j2o_1 = expected;
+        this.m2o_1 = expected;
       }
-      g2o(storage, input, start, end) {
+      j2o(storage, input, start, end) {
         var tmp;
         // Inline function 'kotlin.text.substring' call
-        if (toString(charSequenceSubSequence(input, start, end)) === this.j2o_1) {
+        if (toString(charSequenceSubSequence(input, start, end)) === this.m2o_1) {
           tmp = null;
         } else {
-          tmp = new (WrongConstant())(this.j2o_1);
+          tmp = new (WrongConstant())(this.m2o_1);
         }
         return tmp;
       }
@@ -79,11 +79,11 @@ function NumberConsumer() {
   if (NumberConsumerClass === VOID) {
     class $ {
       constructor(length, whatThisExpects) {
-        this.e2o_1 = length;
-        this.f2o_1 = whatThisExpects;
+        this.h2o_1 = length;
+        this.i2o_1 = whatThisExpects;
       }
       a() {
-        return this.e2o_1;
+        return this.h2o_1;
       }
     }
     initMetadataForClass($, 'NumberConsumer');
@@ -95,7 +95,7 @@ var ExpectedIntClass;
 function ExpectedInt() {
   if (ExpectedIntClass === VOID) {
     class $ {
-      k2o() {
+      n2o() {
         return 'expected an Int value';
       }
     }
@@ -113,10 +113,10 @@ function TooManyDigits() {
   if (TooManyDigitsClass === VOID) {
     class $ {
       constructor(maxDigits) {
-        this.l2o_1 = maxDigits;
+        this.o2o_1 = maxDigits;
       }
-      k2o() {
-        return 'expected at most ' + this.l2o_1 + ' digits';
+      n2o() {
+        return 'expected at most ' + this.o2o_1 + ' digits';
       }
     }
     initMetadataForClass($, 'TooManyDigits');
@@ -129,10 +129,10 @@ function TooFewDigits() {
   if (TooFewDigitsClass === VOID) {
     class $ {
       constructor(minDigits) {
-        this.m2o_1 = minDigits;
+        this.p2o_1 = minDigits;
       }
-      k2o() {
-        return 'expected at least ' + this.m2o_1 + ' digits';
+      n2o() {
+        return 'expected at least ' + this.p2o_1 + ' digits';
       }
     }
     initMetadataForClass($, 'TooFewDigits');
@@ -145,10 +145,10 @@ function WrongConstant() {
   if (WrongConstantClass === VOID) {
     class $ {
       constructor(expected) {
-        this.n2o_1 = expected;
+        this.q2o_1 = expected;
       }
-      k2o() {
-        return "expected '" + this.n2o_1 + "'";
+      n2o() {
+        return "expected '" + this.q2o_1 + "'";
       }
     }
     initMetadataForClass($, 'WrongConstant');
@@ -161,10 +161,10 @@ function Conflicting() {
   if (ConflictingClass === VOID) {
     class $ {
       constructor(conflicting) {
-        this.o2o_1 = conflicting;
+        this.r2o_1 = conflicting;
       }
-      k2o() {
-        return "attempted to overwrite the existing value '" + toString(this.o2o_1) + "'";
+      n2o() {
+        return "attempted to overwrite the existing value '" + toString(this.r2o_1) + "'";
       }
     }
     initMetadataForClass($, 'Conflicting');
@@ -173,7 +173,7 @@ function Conflicting() {
   return ConflictingClass;
 }
 function setWithoutReassigning(_this__u8e3s4, receiver, value) {
-  var tmp0_elvis_lhs = _this__u8e3s4.n2m(receiver, value);
+  var tmp0_elvis_lhs = _this__u8e3s4.q2m(receiver, value);
   var tmp;
   if (tmp0_elvis_lhs == null) {
     return null;
@@ -203,25 +203,25 @@ function UnsignedIntConsumer() {
       constructor(minLength, maxLength, setter, name, multiplyByMinus1) {
         multiplyByMinus1 = multiplyByMinus1 === VOID ? false : multiplyByMinus1;
         super(minLength == maxLength ? minLength : null, name);
-        this.r2o_1 = minLength;
-        this.s2o_1 = maxLength;
-        this.t2o_1 = setter;
-        this.u2o_1 = multiplyByMinus1;
+        this.u2o_1 = minLength;
+        this.v2o_1 = maxLength;
+        this.w2o_1 = setter;
+        this.x2o_1 = multiplyByMinus1;
         // Inline function 'kotlin.require' call
-        if (!(this.a() == null || numberRangeToNumber(1, 9).hm(this.a()))) {
-          var message = 'Invalid length for field ' + this.f2o_1 + ': ' + this.a();
+        if (!(this.a() == null || numberRangeToNumber(1, 9).km(this.a()))) {
+          var message = 'Invalid length for field ' + this.i2o_1 + ': ' + this.a();
           throw IllegalArgumentException().t2(toString(message));
         }
       }
-      g2o(storage, input, start, end) {
+      j2o(storage, input, start, end) {
         var tmp;
-        if (!(this.s2o_1 == null) && (end - start | 0) > this.s2o_1) {
-          tmp = new (TooManyDigits())(this.s2o_1);
-        } else if (!(this.r2o_1 == null) && (end - start | 0) < this.r2o_1) {
-          tmp = new (TooFewDigits())(this.r2o_1);
+        if (!(this.v2o_1 == null) && (end - start | 0) > this.v2o_1) {
+          tmp = new (TooManyDigits())(this.v2o_1);
+        } else if (!(this.u2o_1 == null) && (end - start | 0) < this.u2o_1) {
+          tmp = new (TooFewDigits())(this.u2o_1);
         } else {
           var result = parseAsciiIntOrNull(input, start, end);
-          tmp = result == null ? ExpectedInt_instance : setWithoutReassigning(this.t2o_1, storage, this.u2o_1 ? -result | 0 : result);
+          tmp = result == null ? ExpectedInt_instance : setWithoutReassigning(this.w2o_1, storage, this.x2o_1 ? -result | 0 : result);
         }
         return tmp;
       }

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

@@ -12,8 +12,8 @@ function ParseError() {
   if (ParseErrorClass === VOID) {
     class $ {
       constructor(position, message) {
-        this.v2o_1 = position;
-        this.w2o_1 = message;
+        this.y2o_1 = position;
+        this.z2o_1 = message;
       }
     }
     initMetadataForClass($, 'ParseError');
@@ -31,10 +31,10 @@ var CompanionClass;
 function Companion() {
   if (CompanionClass === VOID) {
     class $ {
-      x2o(indexOfNextUnparsed) {
+      a2p(indexOfNextUnparsed) {
         return _ParseResult___init__impl__gvz3cn(indexOfNextUnparsed);
       }
-      y2o(position, message) {
+      b2p(position, message) {
         return _ParseResult___init__impl__gvz3cn(new (ParseError())(position, message));
       }
     }