npm - @attocash/commons-js - Versions diffs - 6.2.0 → 6.2.1 - Mend

@attocash/commons-js 6.2.0 → 6.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (542) hide show

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

@@ -21,10 +21,10 @@ function format$default(obj, builder, minusNotRequired, $super) {
   minusNotRequired = minusNotRequired === VOID ? false : minusNotRequired;
   var tmp;
   if ($super === VOID) {
-    this.r2n(obj, builder, minusNotRequired);
+    this.h2n(obj, builder, minusNotRequired);
     tmp = Unit_instance;
   } else {
-    tmp = $super.r2n.call(this, obj, builder, minusNotRequired);
+    tmp = $super.h2n.call(this, obj, builder, minusNotRequired);
   }
   return tmp;
 }
@@ -42,16 +42,16 @@ function SpacePaddedFormatter() {
   if (SpacePaddedFormatterClass === VOID) {
     class $ {
       constructor(formatter, padding) {
-        this.s2n_1 = formatter;
-        this.t2n_1 = padding;
+        this.i2n_1 = formatter;
+        this.j2n_1 = padding;
       }
-      r2n(obj, builder, minusNotRequired) {
+      h2n(obj, builder, minusNotRequired) {
         // Inline function 'kotlin.let' call
         var it = StringBuilder().m1();
-        this.s2n_1.r2n(obj, it, minusNotRequired);
+        this.i2n_1.h2n(obj, it, minusNotRequired);
         var string = it.toString();
         // Inline function 'kotlin.repeat' call
-        var times = this.t2n_1 - string.length | 0;
+        var times = this.j2n_1 - string.length | 0;
         var inductionVariable = 0;
         if (inductionVariable < times)
           do {
@@ -63,7 +63,7 @@ function SpacePaddedFormatter() {
         builder.l2(string);
       }
     }
-    protoOf($).n2d = format$default;
+    protoOf($).d2d = format$default;
     initMetadataForClass($, 'SpacePaddedFormatter', VOID, VOID, [FormatterStructure()]);
     SpacePaddedFormatterClass = $;
   }
@@ -74,15 +74,15 @@ function SignedFormatter() {
   if (SignedFormatterClass === VOID) {
     class $ {
       constructor(formatter, allSubFormatsNegative, alwaysOutputSign) {
-        this.u2n_1 = formatter;
-        this.v2n_1 = allSubFormatsNegative;
-        this.w2n_1 = alwaysOutputSign;
+        this.k2n_1 = formatter;
+        this.l2n_1 = allSubFormatsNegative;
+        this.m2n_1 = alwaysOutputSign;
       }
-      r2n(obj, builder, minusNotRequired) {
+      h2n(obj, builder, minusNotRequired) {
         var tmp;
-        if (!minusNotRequired && this.v2n_1(obj)) {
+        if (!minusNotRequired && this.l2n_1(obj)) {
           tmp = _Char___init__impl__6a9atx(45);
-        } else if (this.w2n_1) {
+        } else if (this.m2n_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.u2n_1.r2n(obj, builder, tmp_2);
+        this.k2n_1.h2n(obj, builder, tmp_2);
       }
     }
-    protoOf($).n2d = format$default;
+    protoOf($).d2d = format$default;
     initMetadataForClass($, 'SignedFormatter', VOID, VOID, [FormatterStructure()]);
     SignedFormatterClass = $;
   }
@@ -118,22 +118,22 @@ function ConditionalFormatter() {
   if (ConditionalFormatterClass === VOID) {
     class $ {
       constructor(formatters) {
-        this.x2n_1 = formatters;
+        this.n2n_1 = formatters;
       }
-      r2n(obj, builder, minusNotRequired) {
-        var _iterator__ex2g4s = this.x2n_1.q1();
+      h2n(obj, builder, minusNotRequired) {
+        var _iterator__ex2g4s = this.n2n_1.q1();
         while (_iterator__ex2g4s.r1()) {
           var _destruct__k2r9zo = _iterator__ex2g4s.s1();
-          var condition = _destruct__k2r9zo.if();
-          var formatter = _destruct__k2r9zo.jf();
+          var condition = _destruct__k2r9zo.ef();
+          var formatter = _destruct__k2r9zo.ff();
           if (condition(obj)) {
-            formatter.r2n(obj, builder, minusNotRequired);
+            formatter.h2n(obj, builder, minusNotRequired);
             return Unit_instance;
           }
         }
       }
     }
-    protoOf($).n2d = format$default;
+    protoOf($).d2d = format$default;
     initMetadataForClass($, 'ConditionalFormatter', VOID, VOID, [FormatterStructure()]);
     ConditionalFormatterClass = $;
   }
@@ -144,17 +144,17 @@ function ConcatenatedFormatter() {
   if (ConcatenatedFormatterClass === VOID) {
     class $ {
       constructor(formatters) {
-        this.y2n_1 = formatters;
+        this.o2n_1 = formatters;
       }
-      r2n(obj, builder, minusNotRequired) {
-        var _iterator__ex2g4s = this.y2n_1.q1();
+      h2n(obj, builder, minusNotRequired) {
+        var _iterator__ex2g4s = this.o2n_1.q1();
         while (_iterator__ex2g4s.r1()) {
           var formatter = _iterator__ex2g4s.s1();
-          formatter.r2n(obj, builder, minusNotRequired);
+          formatter.h2n(obj, builder, minusNotRequired);
         }
       }
     }
-    protoOf($).n2d = format$default;
+    protoOf($).d2d = format$default;
     initMetadataForClass($, 'ConcatenatedFormatter', VOID, VOID, [FormatterStructure()]);
     ConcatenatedFormatterClass = $;
   }

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

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

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

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

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

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