@glandais/vcyclist-engine 4.1.0 → 4.2.1

package/vcyclist-engine.js

@@ -30,96 +30,115 @@
   var imul = Math.imul;
   var hypot = Math.hypot;
   var sign = Math.sign;
-  var protoOf = kotlin_kotlin.$_$.d7;
-  var initMetadataForCompanion = kotlin_kotlin.$_$.p6;
+  var protoOf = kotlin_kotlin.$_$.j7;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.v6;
   var VOID = kotlin_kotlin.$_$.a;
-  var getNumberHashCode = kotlin_kotlin.$_$.k6;
-  var equals = kotlin_kotlin.$_$.h6;
-  var initMetadataForClass = kotlin_kotlin.$_$.o6;
-  var toString = kotlin_kotlin.$_$.g7;
-  var hashCode = kotlin_kotlin.$_$.n6;
-  var initMetadataForObject = kotlin_kotlin.$_$.u6;
-  var getBooleanHashCode = kotlin_kotlin.$_$.j6;
+  var getNumberHashCode = kotlin_kotlin.$_$.q6;
+  var equals = kotlin_kotlin.$_$.n6;
+  var initMetadataForClass = kotlin_kotlin.$_$.u6;
+  var toString = kotlin_kotlin.$_$.m7;
+  var hashCode = kotlin_kotlin.$_$.t6;
+  var initMetadataForObject = kotlin_kotlin.$_$.a7;
+  var getBooleanHashCode = kotlin_kotlin.$_$.p6;
   var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.a2;
   var Unit_instance = kotlin_kotlin.$_$.g1;
-  var CoroutineImpl = kotlin_kotlin.$_$.y4;
+  var CoroutineImpl = kotlin_kotlin.$_$.d5;
   var PointPerDistance_instance = kotlin_io_github_glandais_gpx.$_$.k;
   var ElevationStep_instance = kotlin_io_github_glandais_gpx.$_$.h;
-  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.j4;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.o4;
   var PointPerSecond_instance = kotlin_io_github_glandais_gpx.$_$.l;
   var PathSimplifier_instance = kotlin_io_github_glandais_gpx.$_$.i;
-  var initMetadataForCoroutine = kotlin_kotlin.$_$.q6;
-  var enumEntries = kotlin_kotlin.$_$.a5;
-  var Enum = kotlin_kotlin.$_$.l9;
+  var initMetadataForCoroutine = kotlin_kotlin.$_$.w6;
+  var enumEntries = kotlin_kotlin.$_$.f5;
+  var Enum = kotlin_kotlin.$_$.t9;
   var ArrayList_init_$Create$ = kotlin_kotlin.$_$.j1;
   var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.i1;
-  var last = kotlin_kotlin.$_$.p3;
-  var toIntArray = kotlin_kotlin.$_$.b4;
-  var sortedWith = kotlin_kotlin.$_$.z3;
-  var toMutableList = kotlin_kotlin.$_$.f4;
-  var first = kotlin_kotlin.$_$.i3;
-  var removeAll = kotlin_kotlin.$_$.u3;
-  var numberRangeToNumber = kotlin_kotlin.$_$.z6;
+  var last = kotlin_kotlin.$_$.q3;
+  var toIntArray = kotlin_kotlin.$_$.f4;
+  var sortedWith = kotlin_kotlin.$_$.b4;
+  var toMutableList = kotlin_kotlin.$_$.j4;
+  var first = kotlin_kotlin.$_$.j3;
+  var removeAll = kotlin_kotlin.$_$.w3;
+  var numberRangeToNumber = kotlin_kotlin.$_$.f7;
   var collectionSizeOrDefault = kotlin_kotlin.$_$.x2;
   var Vector3D = kotlin_io_github_glandais_elevation.$_$.g;
-  var emptyList = kotlin_kotlin.$_$.f3;
-  var coerceIn = kotlin_kotlin.$_$.n7;
+  var emptyList = kotlin_kotlin.$_$.g3;
+  var coerceIn = kotlin_kotlin.$_$.u7;
   var DouglasPeucker_instance = kotlin_io_github_glandais_elevation.$_$.b;
-  var FunctionAdapter = kotlin_kotlin.$_$.v5;
-  var isInterface = kotlin_kotlin.$_$.w6;
-  var Comparator = kotlin_kotlin.$_$.k9;
-  var compareValues = kotlin_kotlin.$_$.h4;
-  var until = kotlin_kotlin.$_$.r7;
-  var Pair = kotlin_kotlin.$_$.r9;
-  var listOf = kotlin_kotlin.$_$.q3;
+  var FunctionAdapter = kotlin_kotlin.$_$.b6;
+  var isInterface = kotlin_kotlin.$_$.c7;
+  var Comparator = kotlin_kotlin.$_$.s9;
+  var compareValues = kotlin_kotlin.$_$.m4;
+  var until = kotlin_kotlin.$_$.z7;
+  var Pair = kotlin_kotlin.$_$.z9;
+  var listOf = kotlin_kotlin.$_$.r3;
   var Default_getInstance = kotlin_kotlin.$_$.b1;
   var Companion_instance = kotlin_kotlin.$_$.e1;
-  var equals_0 = kotlin_kotlin.$_$.h8;
-  var noWhenBranchMatchedException = kotlin_kotlin.$_$.ia;
-  var isFinite = kotlin_kotlin.$_$.ea;
+  var equals_0 = kotlin_kotlin.$_$.p8;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.qa;
+  var isNaN_0 = kotlin_kotlin.$_$.oa;
+  var isFinite = kotlin_kotlin.$_$.ma;
   var PointField_TEMPERATURE_getInstance = kotlin_io_github_glandais_gpx.$_$.c;
-  var isNaN_0 = kotlin_kotlin.$_$.ga;
   var get_entries = kotlin_io_github_glandais_gpx.$_$.u;
   var Path = kotlin_io_github_glandais_gpx.$_$.t;
+  var arrayCopy = kotlin_kotlin.$_$.t2;
+  var sort = kotlin_kotlin.$_$.d4;
+  var numberToInt = kotlin_kotlin.$_$.h7;
+  var coerceIn_0 = kotlin_kotlin.$_$.v7;
+  var lastOrNull = kotlin_kotlin.$_$.p3;
+  var HashMap_init_$Create$ = kotlin_kotlin.$_$.l1;
+  var fromInt = kotlin_kotlin.$_$.s5;
+  var add = kotlin_kotlin.$_$.i5;
+  var numberToLong = kotlin_kotlin.$_$.v5;
+  var shiftLeft = kotlin_kotlin.$_$.w5;
+  var Long = kotlin_kotlin.$_$.x9;
+  var bitwiseAnd = kotlin_kotlin.$_$.j5;
+  var bitwiseXor = kotlin_kotlin.$_$.l5;
+  var copyOf = kotlin_kotlin.$_$.c3;
+  var coerceAtLeast = kotlin_kotlin.$_$.r7;
+  var round = kotlin_kotlin.$_$.p7;
+  var listOf_0 = kotlin_kotlin.$_$.s3;
+  var Collection = kotlin_kotlin.$_$.n2;
+  var zipWithNext = kotlin_kotlin.$_$.l4;
+  var toDoubleArray = kotlin_kotlin.$_$.e4;
+  var joinToString = kotlin_kotlin.$_$.m3;
   var GpxParser_instance = kotlin_io_github_glandais_gpx.$_$.d;
-  var copyToArray = kotlin_kotlin.$_$.e3;
+  var copyToArray = kotlin_kotlin.$_$.f3;
   var firstTrackAsPath = kotlin_io_github_glandais_gpx.$_$.n;
   var tracksAsPaths = kotlin_io_github_glandais_gpx.$_$.q;
   var segmentsAsPaths = kotlin_io_github_glandais_gpx.$_$.o;
   var GpxPathKind_TRACK_getInstance = kotlin_io_github_glandais_gpx.$_$.b;
-  var setOf = kotlin_kotlin.$_$.x3;
+  var setOf = kotlin_kotlin.$_$.z3;
   var GpxPathKind_ROUTE_getInstance = kotlin_io_github_glandais_gpx.$_$.a;
   var GpxWriter_instance = kotlin_io_github_glandais_gpx.$_$.e;
-  var toList = kotlin_kotlin.$_$.e4;
+  var toList = kotlin_kotlin.$_$.i4;
   var toGpxDocument = kotlin_io_github_glandais_gpx.$_$.p;
   var Companion_getInstance = kotlin_kotlin.$_$.d1;
-  var numberToLong = kotlin_kotlin.$_$.p5;
   var GlobalScope_instance = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.a;
   var promise = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.j;
   var Companion_getInstance_0 = kotlin_io_github_glandais_gpx.$_$.j;
   var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.c2;
   var CsvWriter_instance = kotlin_io_github_glandais_gpx.$_$.f;
-  var firstOrNull = kotlin_kotlin.$_$.i8;
+  var firstOrNull = kotlin_kotlin.$_$.q8;
   var _Char___init__impl__6a9atx = kotlin_kotlin.$_$.b;
-  var Char = kotlin_kotlin.$_$.j9;
+  var Char = kotlin_kotlin.$_$.r9;
   var CsvOptions = kotlin_io_github_glandais_gpx.$_$.r;
   var JsonWriter_instance = kotlin_io_github_glandais_gpx.$_$.g;
   var JsonOptions = kotlin_io_github_glandais_gpx.$_$.s;
   var toFitBytes = kotlin_io_github_glandais_fit.$_$.a;
   var Companion_getInstance_1 = kotlin_kotlin.$_$.c1;
   var DurationUnit_MILLISECONDS_getInstance = kotlin_kotlin.$_$.w;
-  var toDuration = kotlin_kotlin.$_$.i9;
+  var toDuration = kotlin_kotlin.$_$.q9;
   var toFitBytes_0 = kotlin_io_github_glandais_fit.$_$.b;
-  var toNumber = kotlin_kotlin.$_$.u5;
+  var toNumber = kotlin_kotlin.$_$.a6;
   var GpxWaypoint = kotlin_io_github_glandais_gpx.$_$.m;
-  var joinToString = kotlin_kotlin.$_$.l3;
-  var sorted = kotlin_kotlin.$_$.a4;
-  var THROW_CCE = kotlin_kotlin.$_$.u9;
+  var sorted = kotlin_kotlin.$_$.c4;
+  var THROW_CCE = kotlin_kotlin.$_$.ca;
   var CoroutineScope = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.h;
   var ElevationProvider = kotlin_io_github_glandais_elevation.$_$.d;
-  var initMetadataForLambda = kotlin_kotlin.$_$.t6;
-  var constructCallableReference = kotlin_kotlin.$_$.e6;
-  var setOf_0 = kotlin_kotlin.$_$.y3;
+  var initMetadataForLambda = kotlin_kotlin.$_$.z6;
+  var constructCallableReference = kotlin_kotlin.$_$.k6;
+  var setOf_0 = kotlin_kotlin.$_$.a4;
   //endregion
   //region block: pre-declaration
   initMetadataForCompanion(Companion);
@@ -178,6 +197,29 @@
   initMetadataForObject(WindProviderNone, 'WindProviderNone');
   initMetadataForClass(WindProviderConstant, 'WindProviderConstant');
   initMetadataForObject(WPrimeBalanceComputer, 'WPrimeBalanceComputer');
+  initMetadataForObject(BandedLdl, 'BandedLdl');
+  initMetadataForClass(CornerSpan, 'CornerSpan');
+  initMetadataForObject(CornerDetector, 'CornerDetector');
+  initMetadataForClass(CorridorBounds, 'CorridorBounds');
+  initMetadataForObject(Corridor, 'Corridor');
+  initMetadataForClass(Fit, 'Fit');
+  initMetadataForObject(CurvatureEstimator, 'CurvatureEstimator');
+  initMetadataForObject(LocalFrame, 'LocalFrame');
+  initMetadataForCompanion(Companion_11);
+  initMetadataForClass(OffsetEnergy, 'OffsetEnergy');
+  initMetadataForClass(QpResult, 'QpResult');
+  initMetadataForObject(OffsetQp, 'OffsetQp');
+  initMetadataForCompanion(Companion_12);
+  initMetadataForClass(CurvatureOptions, 'CurvatureOptions', CurvatureOptions);
+  initMetadataForObject(PathCurvature, 'PathCurvature');
+  initMetadataForClass(PlanarFrame, 'PlanarFrame');
+  initMetadataForClass(RacingLineReport, 'RacingLineReport');
+  initMetadataForObject(RacingLine, 'RacingLine');
+  initMetadataForCompanion(Companion_13);
+  initMetadataForClass(CorridorMode, 'CorridorMode', VOID, Enum);
+  initMetadataForClass(CornerKind, 'CornerKind', VOID, Enum);
+  initMetadataForCompanion(Companion_14);
+  initMetadataForClass(RacingLineOptions, 'RacingLineOptions', RacingLineOptions);
   initMetadataForLambda(enhance$slambda, CoroutineImpl, VOID, [1]);
   initMetadataForLambda(enhanceWithCourse$slambda, CoroutineImpl, VOID, [1]);
   //endregion
@@ -540,7 +582,7 @@
       new Companion_2();
     return Companion_instance_3;
   }
-  function EnhanceOptions(fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance) {
+  function EnhanceOptions(fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance, curvature, racingLine) {
     Companion_getInstance_5();
     fixElevation = fixElevation === VOID ? true : fixElevation;
     computeMaxSpeeds = computeMaxSpeeds === VOID ? true : computeMaxSpeeds;
@@ -548,27 +590,33 @@
     computeOnePointPerSecond = computeOnePointPerSecond === VOID ? true : computeOnePointPerSecond;
     simplifyPath = simplifyPath === VOID ? new SimplifyPathOptions() : simplifyPath;
     wPrimeBalance = wPrimeBalance === VOID ? new WPrimeBalanceOptions() : wPrimeBalance;
+    curvature = curvature === VOID ? new CurvatureOptions() : curvature;
+    racingLine = racingLine === VOID ? new RacingLineOptions() : racingLine;
     this.fixElevation_1 = fixElevation;
     this.computeMaxSpeeds_1 = computeMaxSpeeds;
     this.virtualizeTrack_1 = virtualizeTrack;
     this.computeOnePointPerSecond_1 = computeOnePointPerSecond;
     this.simplifyPath_1 = simplifyPath;
     this.wPrimeBalance_1 = wPrimeBalance;
+    this.curvature_1 = curvature;
+    this.racingLine_1 = racingLine;
   }
-  protoOf(EnhanceOptions).copy_bazpxz_k$ = function (fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance) {
-    return new EnhanceOptions(fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance);
+  protoOf(EnhanceOptions).copy_i8t81g_k$ = function (fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance, curvature, racingLine) {
+    return new EnhanceOptions(fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance, curvature, racingLine);
   };
-  protoOf(EnhanceOptions).copy$default_2rfmrp_k$ = function (fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance, $super) {
+  protoOf(EnhanceOptions).copy$default_q3w1nk_k$ = function (fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance, curvature, racingLine, $super) {
     fixElevation = fixElevation === VOID ? this.fixElevation_1 : fixElevation;
     computeMaxSpeeds = computeMaxSpeeds === VOID ? this.computeMaxSpeeds_1 : computeMaxSpeeds;
     virtualizeTrack = virtualizeTrack === VOID ? this.virtualizeTrack_1 : virtualizeTrack;
     computeOnePointPerSecond = computeOnePointPerSecond === VOID ? this.computeOnePointPerSecond_1 : computeOnePointPerSecond;
     simplifyPath = simplifyPath === VOID ? this.simplifyPath_1 : simplifyPath;
     wPrimeBalance = wPrimeBalance === VOID ? this.wPrimeBalance_1 : wPrimeBalance;
-    return $super === VOID ? this.copy_bazpxz_k$(fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance) : $super.copy_bazpxz_k$.call(this, fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance);
+    curvature = curvature === VOID ? this.curvature_1 : curvature;
+    racingLine = racingLine === VOID ? this.racingLine_1 : racingLine;
+    return $super === VOID ? this.copy_i8t81g_k$(fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance, curvature, racingLine) : $super.copy_i8t81g_k$.call(this, fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath, wPrimeBalance, curvature, racingLine);
   };
   protoOf(EnhanceOptions).toString = function () {
-    return 'EnhanceOptions(fixElevation=' + this.fixElevation_1 + ', computeMaxSpeeds=' + this.computeMaxSpeeds_1 + ', virtualizeTrack=' + this.virtualizeTrack_1 + ', computeOnePointPerSecond=' + this.computeOnePointPerSecond_1 + ', simplifyPath=' + this.simplifyPath_1.toString() + ', wPrimeBalance=' + this.wPrimeBalance_1.toString() + ')';
+    return 'EnhanceOptions(fixElevation=' + this.fixElevation_1 + ', computeMaxSpeeds=' + this.computeMaxSpeeds_1 + ', virtualizeTrack=' + this.virtualizeTrack_1 + ', computeOnePointPerSecond=' + this.computeOnePointPerSecond_1 + ', simplifyPath=' + this.simplifyPath_1.toString() + ', wPrimeBalance=' + this.wPrimeBalance_1.toString() + ', curvature=' + this.curvature_1.toString() + ', racingLine=' + this.racingLine_1.toString() + ')';
   };
   protoOf(EnhanceOptions).hashCode = function () {
     var result = getBooleanHashCode(this.fixElevation_1);
@@ -577,6 +625,8 @@
     result = imul(result, 31) + getBooleanHashCode(this.computeOnePointPerSecond_1) | 0;
     result = imul(result, 31) + this.simplifyPath_1.hashCode() | 0;
     result = imul(result, 31) + this.wPrimeBalance_1.hashCode() | 0;
+    result = imul(result, 31) + this.curvature_1.hashCode() | 0;
+    result = imul(result, 31) + this.racingLine_1.hashCode() | 0;
     return result;
   };
   protoOf(EnhanceOptions).equals = function (other) {
@@ -596,6 +646,10 @@
       return false;
     if (!this.wPrimeBalance_1.equals(other.wPrimeBalance_1))
       return false;
+    if (!this.curvature_1.equals(other.curvature_1))
+      return false;
+    if (!this.racingLine_1.equals(other.racingLine_1))
+      return false;
     return true;
   };
   function $enhanceCourseCOROUTINE$(_this__u8e3s4, course, options, elevationProvider, resultContinuation) {
@@ -639,6 +693,13 @@
           case 2:
             this.path0__1 = PointPerDistance_instance.compute_7vlifv_k$(this.path0__1, 1.0, 2.0);
             this.path0__1 = ElevationStep_instance.smoothElevation$default_3c035p_k$(this.path0__1);
+            var racingLineApplied = this.options_1.racingLine_1.enabled_1;
+            if (racingLineApplied) {
+              this.path0__1 = RacingLine_instance.compute_uyx32p_k$(this.path0__1, this.options_1.racingLine_1);
+            } else if (this.options_1.curvature_1.enabled_1) {
+              PathCurvature_instance.compute_s9yd16_k$(this.path0__1, this.options_1.curvature_1);
+            }
+
             var working = this.course_1.copy$default_a3dskc_k$(this.course_1.course_1.copy$default_mmxsnj_k$(this.path0__1));
             if (this.options_1.computeMaxSpeeds_1 || this.options_1.virtualizeTrack_1) {
               MaxSpeedComputer_instance.computeMaxSpeeds_jc4v4o_k$(working.course_1);
@@ -658,7 +719,16 @@
             }
 
             if (this.options_1.simplifyPath_1.enabled_1) {
-              this.path0__1 = PathSimplifier_instance.simplify_gxhj7b_k$(this.path0__1, this.options_1.simplifyPath_1.toleranceM_1, this.options_1.simplifyPath_1.zExaggeration_1);
+              var tmp_0;
+              if (racingLineApplied) {
+                var tmp0 = this.options_1.simplifyPath_1.toleranceM_1;
+                var b = this.options_1.racingLine_1.simplifyToleranceCapM_1;
+                tmp_0 = Math.min(tmp0, b);
+              } else {
+                tmp_0 = this.options_1.simplifyPath_1.toleranceM_1;
+              }
+              var tolerance = tmp_0;
+              this.path0__1 = PathSimplifier_instance.simplify_gxhj7b_k$(this.path0__1, tolerance, this.options_1.simplifyPath_1.zExaggeration_1);
             }
 
             return this.path0__1;
@@ -682,7 +752,7 @@
     return new CoursePhysics(new Course(path), RhoProviderEstimate_instance, AeroProviderConstant_instance, WindProviderNone_instance, new PowerProviderConstant(280.0));
   };
   protoOf(Enhancer).enhanceCourseDefault_jm937y_k$ = function (path, elevationProvider, options, $completion) {
-    return this.enhanceCourse_mout3j_k$(this.getDefaultCourse_gqi1xw_k$(path), options.copy$default_2rfmrp_k$(options.fixElevation_1 && !(elevationProvider == null)), elevationProvider, $completion);
+    return this.enhanceCourse_mout3j_k$(this.getDefaultCourse_gqi1xw_k$(path), options.copy$default_q3w1nk_k$(options.fixElevation_1 && !(elevationProvider == null)), elevationProvider, $completion);
   };
   protoOf(Enhancer).enhanceCourse_mout3j_k$ = function (course, options, elevationProvider, $completion) {
     var tmp = new $enhanceCourseCOROUTINE$(this, course, options, elevationProvider, $completion);
@@ -1704,13 +1774,27 @@
     return result;
   }
   function computeRadiusWindowed($this, path, i, k) {
+    var kappa = path.trajectoryCurvature_t4abpc_k$(i);
+    if (!isNaN_0(kappa)) {
+      // Inline function 'kotlin.math.abs' call
+      var tmp0 = Math.abs(kappa);
+      // Inline function 'kotlin.math.max' call
+      var b = 1.0 / 200.0;
+      // Inline function 'kotlin.math.min' call
+      var b_0 = 1.0 / Math.max(tmp0, b);
+      // Inline function 'kotlin.math.max' call
+      var b_1 = Math.min(200.0, b_0);
+      var clamped = Math.max(5.0, b_1);
+      path.setRadius_p1cueq_k$(i, clamped);
+      return clamped;
+    }
     // Inline function 'kotlin.math.max' call
-    var b = i - k | 0;
-    var mini = Math.max(0, b);
-    var tmp0 = path.size_1 - 1 | 0;
+    var b_2 = i - k | 0;
+    var mini = Math.max(0, b_2);
+    var tmp0_0 = path.size_1 - 1 | 0;
     // Inline function 'kotlin.math.min' call
-    var b_0 = i + k | 0;
-    var maxi = Math.min(tmp0, b_0);
+    var b_3 = i + k | 0;
+    var maxi = Math.min(tmp0_0, b_3);
     var totalBearingChange = $this.normalizeAngleDiff_6gshzi_k$(path.bearing_fz5vxm_k$(maxi) - path.bearing_fz5vxm_k$(mini));
     var totalDistance = path.distance_5s4s77_k$(maxi) - path.distance_5s4s77_k$(mini);
     // Inline function 'kotlin.math.abs' call
@@ -1722,10 +1806,10 @@
     var raw = totalDistance / Math.abs(totalBearingChange);
     // Inline function 'kotlin.math.min' call
     // Inline function 'kotlin.math.max' call
-    var b_1 = Math.min(200.0, raw);
-    var clamped = Math.max(5.0, b_1);
-    path.setRadius_p1cueq_k$(i, clamped);
-    return clamped;
+    var b_4 = Math.min(200.0, raw);
+    var clamped_0 = Math.max(5.0, b_4);
+    path.setRadius_p1cueq_k$(i, clamped_0);
+    return clamped_0;
   }
   function computeBrakingLimit($this, course, currentIndex, nextIndex, corneringLimit) {
     var path = course.path_1;
@@ -1887,7 +1971,7 @@
       path.setPBrake_iza4qj_k$(i, 0.0);
       return Unit_instance;
     }
-    var dtSeconds = path.dt_17uzp4_k$(i) / 1000.0;
+    var dtSeconds = path.dt_17uzp4_k$(i);
     if (dtSeconds <= 0.0) {
       path.setPComputedTotalPower_wm6di_k$(i, 0.0);
       path.setPComputedWheelPower_qplog3_k$(i, 0.0);
@@ -1982,7 +2066,7 @@
       this.reset_5u6xz3_k$();
     }
     if (pointIndex > this.lastIndex_1) {
-      var elapsedS = path.elapsed_7307rw_k$(pointIndex) / 1000.0;
+      var elapsedS = path.elapsed_7307rw_k$(pointIndex);
       var dtS = elapsedS - this.lastElapsedS_1;
       if (dtS > 0.0 && isFinite(dtS)) {
         this.wPrimeBalanceJ_1 = WPrimeBalanceComputer_instance.step_447nu7_k$(this.wPrimeBalanceJ_1, this.lastPowerW_1, this.criticalPowerW_1, this.wPrimeJ_1, dtS);
@@ -2071,7 +2155,7 @@
       this.reset_5u6xz3_k$();
     }
     if (pointIndex > this.lastIndex_1) {
-      var elapsedS = path.elapsed_7307rw_k$(pointIndex) / 1000.0;
+      var elapsedS = path.elapsed_7307rw_k$(pointIndex);
       var dtS = elapsedS - this.lastElapsedS_1;
       if (dtS > 0.0 && isFinite(dtS)) {
         var tmp = this;
@@ -2123,7 +2207,7 @@
     }
     if (pointIndex === this.lastIndex_1)
       return this.lastPowerW_1;
-    var elapsedS = path.elapsed_7307rw_k$(pointIndex) / 1000.0;
+    var elapsedS = path.elapsed_7307rw_k$(pointIndex);
     var dtS = elapsedS - this.lastElapsedS_1;
     var tmp;
     if (dtS > 0.0 && isFinite(dtS)) {
@@ -2227,7 +2311,7 @@
       this.multiplier_1 = this.smooth_uy9sy9_k$(this.multiplier_1, this.rawMultiplier_2rfnpc_k$(path, pointIndex), dx);
       if (isFinite(distanceM))
         this.lastDistanceM_1 = distanceM;
-      var elapsedS = path.elapsed_7307rw_k$(pointIndex) / 1000.0;
+      var elapsedS = path.elapsed_7307rw_k$(pointIndex);
       var dtS = elapsedS - this.lastElapsedS_1;
       if (dtS > 0.0 && isFinite(dtS)) {
         this.energyDebtJ_1 = this.energyDebtJ_1 + (this.lastDeliveredW_1 - this.lastTargetW_1) * dtS;
@@ -2369,7 +2453,7 @@
       if (dx <= 0.0) {
         copyAllFields(this, input, i, out, i);
         out.setTime_rfmvcd_k$(i, timeMs);
-        out.setElapsed_916ug_k$(i, timeMs - startTimeMs);
+        out.setElapsed_916ug_k$(i, (timeMs - startTimeMs) / 1000.0);
         out.setDx_uk0ky4_k$(i, 0.0);
         out.setDt_sgarxs_k$(i, 0.0);
         out.setSpeed_1slan1_k$(i, speed);
@@ -2389,9 +2473,9 @@
       speed = speedNew;
       timeMs = timeMs + dt * 1000.0;
       out.setTime_rfmvcd_k$(i, timeMs);
-      out.setElapsed_916ug_k$(i, timeMs - startTimeMs);
+      out.setElapsed_916ug_k$(i, (timeMs - startTimeMs) / 1000.0);
       out.setDx_uk0ky4_k$(i, dx);
-      out.setDt_sgarxs_k$(i, dt * 1000.0);
+      out.setDt_sgarxs_k$(i, dt);
       out.setSpeed_1slan1_k$(i, speed);
       out.setVirtSpeedCurrent_kvg8yv_k$(i, speed);
       i = i + 1 | 0;
@@ -2522,140 +2606,2091 @@
   function WPrimeBalanceComputer_getInstance() {
     return WPrimeBalanceComputer_instance;
   }
-  function get_POWER_PROVIDER_KEYS() {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return POWER_PROVIDER_KEYS;
-  }
-  var POWER_PROVIDER_KEYS;
-  function get_CYCLIST_KEYS() {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return CYCLIST_KEYS;
-  }
-  var CYCLIST_KEYS;
-  function get_BIKE_KEYS() {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return BIKE_KEYS;
+  function BandedLdl() {
   }
-  var BIKE_KEYS;
-  function get_WIND_KEYS() {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return WIND_KEYS;
+  protoOf(BandedLdl).factor_n459o6_k$ = function (a0, a1, a2) {
+    var n = a0.length;
+    if (n === 0)
+      return true;
+    var l1 = new Float64Array(n);
+    var l2 = new Float64Array(n);
+    var d = new Float64Array(n);
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var dm1 = i >= 1 ? d[i - 1 | 0] : 0.0;
+        var dm2 = i >= 2 ? d[i - 2 | 0] : 0.0;
+        l2[i] = i >= 2 ? a2[i - 2 | 0] / dm2 : 0.0;
+        var tmp;
+        if (i >= 1) {
+          var correction = i >= 2 ? l2[i] * l1[i - 1 | 0] * dm2 : 0.0;
+          tmp = (a1[i - 1 | 0] - correction) / dm1;
+        } else {
+          tmp = 0.0;
+        }
+        l1[i] = tmp;
+        var pivot = a0[i];
+        if (i >= 1)
+          pivot = pivot - l1[i] * l1[i] * dm1;
+        if (i >= 2)
+          pivot = pivot - l2[i] * l2[i] * dm2;
+        if (!(pivot > 0.0) || !isFinite(pivot))
+          return false;
+        d[i] = pivot;
+      }
+       while (inductionVariable < n);
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = d.length;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp_0 = d;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    arrayCopy(tmp_0, a0, 0, 0, endIndex);
+    var inductionVariable_0 = 0;
+    if (inductionVariable_0 < n)
+      do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        if (i_0 >= 1) {
+          a1[i_0 - 1 | 0] = l1[i_0];
+        }
+        if (i_0 >= 2) {
+          a2[i_0 - 2 | 0] = l2[i_0];
+        }
+      }
+       while (inductionVariable_0 < n);
+    return true;
+  };
+  protoOf(BandedLdl).solveInPlace_jrw92v_k$ = function (d, l1, l2, b) {
+    var n = d.length;
+    if (n === 0)
+      return Unit_instance;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var v = b[i];
+        if (i >= 1)
+          v = v - l1[i - 1 | 0] * b[i - 1 | 0];
+        if (i >= 2)
+          v = v - l2[i - 2 | 0] * b[i - 2 | 0];
+        b[i] = v;
+      }
+       while (inductionVariable < n);
+    var inductionVariable_0 = 0;
+    if (inductionVariable_0 < n)
+      do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        b[i_0] = b[i_0] / d[i_0];
+      }
+       while (inductionVariable_0 < n);
+    var inductionVariable_1 = n - 1 | 0;
+    if (0 <= inductionVariable_1)
+      do {
+        var i_1 = inductionVariable_1;
+        inductionVariable_1 = inductionVariable_1 + -1 | 0;
+        var v_0 = b[i_1];
+        if ((i_1 + 1 | 0) < n)
+          v_0 = v_0 - l1[i_1] * b[i_1 + 1 | 0];
+        if ((i_1 + 2 | 0) < n)
+          v_0 = v_0 - l2[i_1] * b[i_1 + 2 | 0];
+        b[i_1] = v_0;
+      }
+       while (0 <= inductionVariable_1);
+  };
+  protoOf(BandedLdl).multiply_dwj15t_k$ = function (a0, a1, a2, x, y) {
+    var n = a0.length;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var v = a0[i] * x[i];
+        if (i >= 1)
+          v = v + a1[i - 1 | 0] * x[i - 1 | 0];
+        if ((i + 1 | 0) < n)
+          v = v + a1[i] * x[i + 1 | 0];
+        if (i >= 2)
+          v = v + a2[i - 2 | 0] * x[i - 2 | 0];
+        if ((i + 2 | 0) < n)
+          v = v + a2[i] * x[i + 2 | 0];
+        y[i] = v;
+      }
+       while (inductionVariable < n);
+  };
+  var BandedLdl_instance;
+  function BandedLdl_getInstance() {
+    return BandedLdl_instance;
+  }
+  function CornerSpan(fromIndex, untilIndex, apexIndex, kind, turnRad, direction, radiusQ20M, radiusMinM, lengthM) {
+    this.fromIndex_1 = fromIndex;
+    this.untilIndex_1 = untilIndex;
+    this.apexIndex_1 = apexIndex;
+    this.kind_1 = kind;
+    this.turnRad_1 = turnRad;
+    this.direction_1 = direction;
+    this.radiusQ20M_1 = radiusQ20M;
+    this.radiusMinM_1 = radiusMinM;
+    this.lengthM_1 = lengthM;
+  }
+  protoOf(CornerSpan).toString = function () {
+    return 'CornerSpan(fromIndex=' + this.fromIndex_1 + ', untilIndex=' + this.untilIndex_1 + ', apexIndex=' + this.apexIndex_1 + ', kind=' + this.kind_1.toString() + ', turnRad=' + this.turnRad_1 + ', direction=' + this.direction_1 + ', radiusQ20M=' + this.radiusQ20M_1 + ', radiusMinM=' + this.radiusMinM_1 + ', lengthM=' + this.lengthM_1 + ')';
+  };
+  protoOf(CornerSpan).hashCode = function () {
+    var result = this.fromIndex_1;
+    result = imul(result, 31) + this.untilIndex_1 | 0;
+    result = imul(result, 31) + this.apexIndex_1 | 0;
+    result = imul(result, 31) + this.kind_1.hashCode() | 0;
+    result = imul(result, 31) + getNumberHashCode(this.turnRad_1) | 0;
+    result = imul(result, 31) + this.direction_1 | 0;
+    result = imul(result, 31) + getNumberHashCode(this.radiusQ20M_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.radiusMinM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.lengthM_1) | 0;
+    return result;
+  };
+  protoOf(CornerSpan).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CornerSpan))
+      return false;
+    if (!(this.fromIndex_1 === other.fromIndex_1))
+      return false;
+    if (!(this.untilIndex_1 === other.untilIndex_1))
+      return false;
+    if (!(this.apexIndex_1 === other.apexIndex_1))
+      return false;
+    if (!this.kind_1.equals(other.kind_1))
+      return false;
+    if (!equals(this.turnRad_1, other.turnRad_1))
+      return false;
+    if (!(this.direction_1 === other.direction_1))
+      return false;
+    if (!equals(this.radiusQ20M_1, other.radiusQ20M_1))
+      return false;
+    if (!equals(this.radiusMinM_1, other.radiusMinM_1))
+      return false;
+    if (!equals(this.lengthM_1, other.lengthM_1))
+      return false;
+    return true;
+  };
+  function radiusPercentile($this, kappa, from, until, fraction) {
+    var count = until - from | 0;
+    if (count <= 0)
+      return Infinity;
+    var tmp = 0;
+    var tmp_0 = new Float64Array(count);
+    while (tmp < count) {
+      var tmp_1 = tmp;
+      tmp_0[tmp_1] = CurvatureEstimator_instance.radiusAt_umgvjz_k$(kappa[from + tmp_1 | 0]);
+      tmp = tmp + 1 | 0;
+    }
+    var radii = tmp_0;
+    sort(radii);
+    var idx = coerceIn_0(numberToInt((count - 1 | 0) * fraction), 0, count - 1 | 0);
+    return radii[idx];
   }
-  var WIND_KEYS;
-  function get_ENHANCE_OPTIONS_KEYS() {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return ENHANCE_OPTIONS_KEYS;
+  function CornerDetector() {
   }
-  var ENHANCE_OPTIONS_KEYS;
-  function parseGpxWaypoints(xml) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    // Inline function 'kotlin.collections.map' call
-    var this_0 = GpxParser_instance.parse$default_ez0f31_k$(xml).waypoints_1;
-    // Inline function 'kotlin.collections.mapTo' call
-    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
-    var _iterator__ex2g4s = this_0.iterator_jk1svi_k$();
-    while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
-      var item = _iterator__ex2g4s.next_20eer_k$();
-      var tmp$ret$2 = waypointObj(item);
-      destination.add_utx5q5_k$(tmp$ret$2);
+  protoOf(CornerDetector).detect_cq5dkx_k$ = function (frame, options, widthM) {
+    var n = frame.get_size_woubt6_k$();
+    if (n < 3)
+      return emptyList();
+    var enter = 1.0 / options.cornerEnterRadiusM_1;
+    var exit = 1.0 / options.cornerExitRadiusM_1;
+    var kappa = frame.kappa_1;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var raw = ArrayList_init_$Create$();
+    var start = -1;
+    var sign = 0;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var k = kappa[i];
+        // Inline function 'kotlin.math.abs' call
+        var a = Math.abs(k);
+        var tmp;
+        if (k > 0) {
+          tmp = 1;
+        } else if (k < 0) {
+          tmp = -1;
+        } else {
+          tmp = 0;
+        }
+        var s = tmp;
+        if (start < 0) {
+          if (a > enter && !(s === 0)) {
+            start = i;
+            sign = s;
+          }
+        } else {
+          var sameSign = s === sign || s === 0;
+          if (a < exit || !sameSign) {
+            // Inline function 'kotlin.intArrayOf' call
+            var tmp$ret$2 = new Int32Array([start, i, sign]);
+            raw.add_utx5q5_k$(tmp$ret$2);
+            start = a > enter && !(s === 0) && !sameSign ? i : -1;
+            if (start >= 0)
+              sign = s;
+          }
+        }
+      }
+       while (inductionVariable < n);
+    if (start >= 0) {
+      // Inline function 'kotlin.intArrayOf' call
+      var tmp$ret$3 = new Int32Array([start, n, sign]);
+      raw.add_utx5q5_k$(tmp$ret$3);
     }
-    // Inline function 'kotlin.collections.toTypedArray' call
-    return copyToArray(destination);
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var merged = ArrayList_init_$Create$();
+    var _iterator__ex2g4s = raw.iterator_jk1svi_k$();
+    $l$loop: while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
+      var span = _iterator__ex2g4s.next_20eer_k$();
+      var last = lastOrNull(merged);
+      if (!(last == null) && last[2] === span[2]) {
+        var tmp0 = span[0];
+        // Inline function 'kotlin.comparisons.minOf' call
+        var b = n - 1 | 0;
+        var tmp$ret$5 = Math.min(tmp0, b);
+        var tmp_0 = frame.s_1[tmp$ret$5];
+        var tmp0_0 = last[1];
+        // Inline function 'kotlin.comparisons.minOf' call
+        var b_0 = n - 1 | 0;
+        var tmp$ret$6 = Math.min(tmp0_0, b_0);
+        var gap = tmp_0 - frame.s_1[tmp$ret$6];
+        var tmp0_1 = span[0];
+        // Inline function 'kotlin.comparisons.minOf' call
+        var b_1 = widthM.length - 1 | 0;
+        var w = widthM[Math.min(tmp0_1, b_1)];
+        // Inline function 'kotlin.math.max' call
+        var b_2 = 3.0 * w;
+        if (gap < Math.max(15.0, b_2)) {
+          last[1] = span[1];
+          continue $l$loop;
+        }
+      }
+      merged.add_utx5q5_k$(span);
+    }
+    var minTurn = options.minCornerTurnDeg_1 * 3.141592653589793 / 180.0;
+    var hairpinTurn = options.hairpinTurnDeg_1 * 3.141592653589793 / 180.0;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var out = ArrayList_init_$Create$();
+    var _iterator__ex2g4s_0 = merged.iterator_jk1svi_k$();
+    $l$loop_2: while (_iterator__ex2g4s_0.hasNext_bitz1p_k$()) {
+      var span_0 = _iterator__ex2g4s_0.next_20eer_k$();
+      var from = span_0[0];
+      // Inline function 'kotlin.comparisons.minOf' call
+      var a_0 = span_0[1];
+      var until = Math.min(a_0, n);
+      if ((until - from | 0) < 2)
+        continue $l$loop_2;
+      var lengthM = frame.s_1[until - 1 | 0] - frame.s_1[from];
+      if (lengthM < options.minCornerLengthM_1)
+        continue $l$loop_2;
+      var turn = frame.theta_1[until - 1 | 0] - frame.theta_1[from];
+      // Inline function 'kotlin.math.abs' call
+      if (Math.abs(turn) < minTurn)
+        continue $l$loop_2;
+      var apex = from;
+      var peak = 0.0;
+      var minRadius = 1.7976931348623157E308;
+      var inductionVariable_0 = from;
+      if (inductionVariable_0 < until)
+        do {
+          var i_0 = inductionVariable_0;
+          inductionVariable_0 = inductionVariable_0 + 1 | 0;
+          // Inline function 'kotlin.math.abs' call
+          var x = kappa[i_0];
+          var a_1 = Math.abs(x);
+          if (a_1 > peak) {
+            peak = a_1;
+            apex = i_0;
+          }
+          var r = CurvatureEstimator_instance.radiusAt_umgvjz_k$(kappa[i_0]);
+          if (r < minRadius)
+            minRadius = r;
+        }
+         while (inductionVariable_0 < until);
+      var q20 = radiusPercentile(this, kappa, from, until, 0.2);
+      var tmp_1;
+      // Inline function 'kotlin.math.abs' call
+      if (Math.abs(turn) >= hairpinTurn) {
+        tmp_1 = CornerKind_HAIRPIN_getInstance();
+      } else {
+        if (q20 >= options.gentleRadiusM_1) {
+          tmp_1 = CornerKind_GENTLE_getInstance();
+        } else {
+          tmp_1 = CornerKind_CORNER_getInstance();
+        }
+      }
+      var kind = tmp_1;
+      out.add_utx5q5_k$(new CornerSpan(from, until, apex, kind, turn, span_0[2], q20, minRadius === 1.7976931348623157E308 ? Infinity : minRadius, lengthM));
+    }
+    return out;
+  };
+  var CornerDetector_instance;
+  function CornerDetector_getInstance() {
+    return CornerDetector_instance;
   }
-  function parseGpx(xml) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return firstTrackAsPath(GpxParser_instance.parse$default_ez0f31_k$(xml));
+  function CorridorBounds(lo, hi, halfWidthM) {
+    this.lo_1 = lo;
+    this.hi_1 = hi;
+    this.halfWidthM_1 = halfWidthM;
   }
-  function parseGpxTracks(xml) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    // Inline function 'kotlin.collections.toTypedArray' call
-    var this_0 = tracksAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml));
-    return copyToArray(this_0);
+  function applyRegularityClamp($this, frame, options, lo, hi) {
+    var inductionVariable = 0;
+    var last = frame.get_size_woubt6_k$();
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.math.abs' call
+        var x = frame.kappa_1[i];
+        // Inline function 'kotlin.math.max' call
+        var a = Math.abs(x);
+        var tmp$ret$1 = Math.max(a, 1.0E-9);
+        var limit = options.regularityFactor_1 / tmp$ret$1;
+        var tmp0 = lo[i];
+        // Inline function 'kotlin.math.max' call
+        var b = -limit;
+        lo[i] = Math.max(tmp0, b);
+        // Inline function 'kotlin.math.min' call
+        var a_0 = hi[i];
+        hi[i] = Math.min(a_0, limit);
+      }
+       while (inductionVariable < last);
   }
-  function parseGpxSegments(xml) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    // Inline function 'kotlin.collections.toTypedArray' call
-    var this_0 = segmentsAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml));
-    return copyToArray(this_0);
+  function applySelfProximityClamp($this, frame, options, lo, hi) {
+    var n = frame.get_size_woubt6_k$();
+    var buckets = HashMap_init_$Create$();
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.collections.getOrPut' call
+        var key = cellKey($this, bucketOf($this, frame.x_1[i]), bucketOf($this, frame.y_1[i]));
+        var value = buckets.get_wei43m_k$(key);
+        var tmp;
+        if (value == null) {
+          // Inline function 'kotlin.collections.mutableListOf' call
+          var answer = ArrayList_init_$Create$();
+          buckets.put_4fpzoq_k$(key, answer);
+          tmp = answer;
+        } else {
+          tmp = value;
+        }
+        tmp.add_utx5q5_k$(i);
+      }
+       while (inductionVariable < n);
+    var inductionVariable_0 = 0;
+    if (inductionVariable_0 < n)
+      $l$loop_1: do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        var bx = bucketOf($this, frame.x_1[i_0]);
+        var by = bucketOf($this, frame.y_1[i_0]);
+        var nearest = 1.7976931348623157E308;
+        var inductionVariable_1 = -1;
+        if (inductionVariable_1 <= 1)
+          do {
+            var dx = inductionVariable_1;
+            inductionVariable_1 = inductionVariable_1 + 1 | 0;
+            var inductionVariable_2 = -1;
+            if (inductionVariable_2 <= 1)
+              $l$loop: do {
+                var dy = inductionVariable_2;
+                inductionVariable_2 = inductionVariable_2 + 1 | 0;
+                // Inline function 'kotlin.Long.plus' call
+                var tmp_0 = add(bx, fromInt(dx));
+                // Inline function 'kotlin.Long.plus' call
+                var tmp$ret$4 = add(by, fromInt(dy));
+                var tmp0_elvis_lhs = buckets.get_wei43m_k$(cellKey($this, tmp_0, tmp$ret$4));
+                var tmp_1;
+                if (tmp0_elvis_lhs == null) {
+                  continue $l$loop;
+                } else {
+                  tmp_1 = tmp0_elvis_lhs;
+                }
+                var cell = tmp_1;
+                var _iterator__ex2g4s = cell.iterator_jk1svi_k$();
+                $l$loop_0: while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
+                  var j = _iterator__ex2g4s.next_20eer_k$();
+                  // Inline function 'kotlin.math.abs' call
+                  var x = frame.s_1[j] - frame.s_1[i_0];
+                  var alongPath = Math.abs(x);
+                  var ddx = frame.x_1[j] - frame.x_1[i_0];
+                  var ddy = frame.y_1[j] - frame.y_1[i_0];
+                  // Inline function 'kotlin.math.sqrt' call
+                  var x_0 = ddx * ddx + ddy * ddy;
+                  var d = Math.sqrt(x_0);
+                  // Inline function 'kotlin.math.abs' call
+                  var x_1 = LocalFrame_instance.unwrap_i6c8al_k$(frame.theta_1[j] - frame.theta_1[i_0]);
+                  var headingGap = Math.abs(x_1);
+                  var sameRoad = alongPath <= options.selfProximityGapM_1 && headingGap < 1.5707963267948966;
+                  if (sameRoad)
+                    continue $l$loop_0;
+                  if (d < nearest)
+                    nearest = d;
+                }
+              }
+               while (inductionVariable_2 <= 1);
+          }
+           while (inductionVariable_1 <= 1);
+        if (nearest === 1.7976931348623157E308)
+          continue $l$loop_1;
+        // Inline function 'kotlin.math.max' call
+        var b = nearest / 2.0 - 0.5;
+        var allowed = Math.max(0.0, b);
+        var tmp0 = lo[i_0];
+        // Inline function 'kotlin.math.max' call
+        var b_0 = -allowed;
+        lo[i_0] = Math.max(tmp0, b_0);
+        // Inline function 'kotlin.math.min' call
+        var a = hi[i_0];
+        hi[i_0] = Math.min(a, allowed);
+      }
+       while (inductionVariable_0 < n);
   }
-  function parseGpxTracksOnly(xml) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    // Inline function 'kotlin.collections.toTypedArray' call
-    var this_0 = tracksAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml), setOf(GpxPathKind_TRACK_getInstance()));
-    return copyToArray(this_0);
+  function bucketOf($this, v) {
+    // Inline function 'kotlin.math.floor' call
+    var x = v / 12.0;
+    var tmp$ret$0 = Math.floor(x);
+    return numberToLong(tmp$ret$0);
   }
-  function parseGpxRoutesOnly(xml) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    // Inline function 'kotlin.collections.toTypedArray' call
-    var this_0 = tracksAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml), setOf(GpxPathKind_ROUTE_getInstance()));
-    return copyToArray(this_0);
+  function cellKey($this, bx, by) {
+    return bitwiseXor(shiftLeft(bx, 32), bitwiseAnd(by, new Long(-1, 0)));
   }
-  function writeGpxTracks(paths, waypoints, writeExtensions) {
-    var tmp;
-    if (waypoints === VOID) {
-      // Inline function 'kotlin.emptyArray' call
-      tmp = [];
-    } else {
-      tmp = waypoints;
-    }
-    waypoints = tmp;
-    writeExtensions = writeExtensions === VOID ? true : writeExtensions;
-    _init_properties_EngineJsApi_kt__9bputf();
-    var tmp_0 = GpxWriter_instance;
-    var tmp_1 = toList(paths);
-    // Inline function 'kotlin.collections.map' call
-    // Inline function 'kotlin.collections.mapTo' call
-    var destination = ArrayList_init_$Create$_0(waypoints.length);
+  function applyPins($this, frame, options, lo, hi) {
+    var n = frame.get_size_woubt6_k$();
+    // Inline function 'kotlin.intArrayOf' call
+    var indexedObject = new Int32Array([0, 1, n - 2 | 0, n - 1 | 0]);
     var inductionVariable = 0;
-    var last = waypoints.length;
+    var last = indexedObject.length;
     while (inductionVariable < last) {
-      var item = waypoints[inductionVariable];
+      var i = indexedObject[inductionVariable];
       inductionVariable = inductionVariable + 1 | 0;
-      var tmp$ret$3 = toGpxWaypoint(item);
-      destination.add_utx5q5_k$(tmp$ret$3);
+      if (0 <= i ? i < n : false) {
+        lo[i] = 0.0;
+        hi[i] = 0.0;
+      }
     }
-    return tmp_0.write$default_koqy5u_k$(tmp_1, VOID, VOID, destination, VOID, writeExtensions);
-  }
-  function pathSize(path) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return path.size_1;
-  }
-  function pathTotalDistance(path) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return path.totalDistance_1;
-  }
-  function pathDurationMs(path) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return path.durationMs_1;
-  }
-  function pathElevationGain(path) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return path.elevationGain_1;
-  }
-  function pathElevationLoss(path) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return path.elevationLoss_1;
-  }
-  function pointAt(path, i) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    return pointObj(path.latitudeDeg_i25sm6_k$(i), path.longitudeDeg_ikk1un_k$(i), path.elevation_iziwkb_k$(i), path.time_ryc845_k$(i), path.speed_npav2n_k$(i), path.pComputedPower_g6dnn4_k$(i), path.distance_5s4s77_k$(i), path.grade_c4yjz5_k$(i));
+    var straightKappa = 1.0 / options.straightRadiusM_1;
+    var runStart = -1;
+    var inductionVariable_0 = 0;
+    if (inductionVariable_0 < n)
+      do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        // Inline function 'kotlin.math.abs' call
+        var x = frame.kappa_1[i_0];
+        var straight = Math.abs(x) < straightKappa;
+        if (straight) {
+          if (runStart < 0)
+            runStart = i_0;
+        } else {
+          pinRunMidpoint($this, frame, options, runStart, i_0, lo, hi);
+          runStart = -1;
+        }
+      }
+       while (inductionVariable_0 < n);
+    pinRunMidpoint($this, frame, options, runStart, n, lo, hi);
   }
-  function writeGpx(path, writeExtensions) {
-    writeExtensions = writeExtensions === VOID ? true : writeExtensions;
-    _init_properties_EngineJsApi_kt__9bputf();
-    return GpxWriter_instance.write_7y52k2_k$(toGpxDocument(path, VOID, 'virtualized'), writeExtensions);
+  function pinRunMidpoint($this, frame, options, from, until, lo, hi) {
+    if (from < 0 || (until - from | 0) < 2)
+      return Unit_instance;
+    if (frame.s_1[until - 1 | 0] - frame.s_1[from] < options.straightRunM_1)
+      return Unit_instance;
+    var mid = (from + until | 0) / 2 | 0;
+    // Inline function 'kotlin.intArrayOf' call
+    var indexedObject = new Int32Array([mid, mid + 1 | 0]);
+    var inductionVariable = 0;
+    var last = indexedObject.length;
+    while (inductionVariable < last) {
+      var i = indexedObject[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      if (0 <= i ? i < frame.get_size_woubt6_k$() : false) {
+        lo[i] = 0.0;
+        hi[i] = 0.0;
+      }
+    }
   }
-  function writeGpxAt(path, startTimeEpochMs, writeExtensions) {
-    writeExtensions = writeExtensions === VOID ? true : writeExtensions;
-    _init_properties_EngineJsApi_kt__9bputf();
-    return GpxWriter_instance.write_7y52k2_k$(toGpxDocument(path, VOID, 'virtualized', Companion_getInstance().fromEpochMilliseconds_uaz65_k$(numberToLong(startTimeEpochMs))), writeExtensions);
+  function Corridor() {
+    this.MAX_HALF_WIDTH_M_1 = 6.0;
+    this.GRID_M_1 = 12.0;
+    this.PROXIMITY_CLEARANCE_M_1 = 0.5;
+    this.SAME_ROAD_HEADING_RAD_1 = 1.5707963267948966;
   }
-  function enhance(path, options) {
-    _init_properties_EngineJsApi_kt__9bputf();
-    var tmp = GlobalScope_instance;
-    return promise(tmp, VOID, VOID, enhance$slambda_0(options, path, null));
+  protoOf(Corridor).resolveWidth_feg61f_k$ = function (path, frame, options) {
+    var raw = new Float64Array(frame.get_size_woubt6_k$());
+    var inductionVariable = 0;
+    var last = raw.length - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var w = path.roadWidth_7zv9qq_k$(i);
+        raw[i] = isNaN_0(w) || w <= 0.0 ? options.defaultRoadWidthM_1 : w;
+      }
+       while (inductionVariable <= last);
+    return LocalFrame_instance.smooth_kce7pb_k$(raw, frame.s_1, options.widthSmoothWindowM_1);
+  };
+  protoOf(Corridor).build_fyfb0s_k$ = function (frame, widthM, options) {
+    var n = frame.get_size_woubt6_k$();
+    var lo = new Float64Array(n);
+    var hi = new Float64Array(n);
+    var half = new Float64Array(n);
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var h = coerceIn(widthM[i] / 2.0 - options.edgeMarginM_1, 0.0, 6.0);
+        half[i] = h;
+        switch (options.corridor_1.ordinal_1) {
+          case 0:
+            lo[i] = -h;
+            hi[i] = 0.0;
+            break;
+          case 1:
+            lo[i] = 0.0;
+            hi[i] = h;
+            break;
+          case 2:
+            lo[i] = -h;
+            hi[i] = h;
+            break;
+          default:
+            noWhenBranchMatchedException();
+            break;
+        }
+      }
+       while (inductionVariable < n);
+    applyRegularityClamp(this, frame, options, lo, hi);
+    applySelfProximityClamp(this, frame, options, lo, hi);
+    applyPins(this, frame, options, lo, hi);
+    var inductionVariable_0 = 0;
+    if (inductionVariable_0 < n)
+      do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        if (lo[i_0] > hi[i_0]) {
+          var mid = (lo[i_0] + hi[i_0]) / 2.0;
+          lo[i_0] = mid;
+          hi[i_0] = mid;
+        }
+      }
+       while (inductionVariable_0 < n);
+    return new CorridorBounds(lo, hi, half);
+  };
+  var Corridor_instance;
+  function Corridor_getInstance() {
+    return Corridor_instance;
   }
-  function enhanceWithCourse(path, cyclist, bike, wind, power, options) {
+  function medianSigma($this, frame, halfWidthM) {
+    var n = frame.get_size_woubt6_k$();
+    if (n === 0)
+      return 0.0;
+    var values = new Float64Array(n);
+    var count = 0;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      $l$loop: do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp0_elvis_lhs = fitSlope($this, frame, i, halfWidthM);
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          continue $l$loop;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        var fit = tmp;
+        var _unary__edvuaz = count;
+        count = _unary__edvuaz + 1 | 0;
+        values[_unary__edvuaz] = fit.residualSigma_1;
+      }
+       while (inductionVariable < n);
+    if (count === 0)
+      return 0.0;
+    var trimmed = copyOf(values, count);
+    sort(trimmed);
+    return trimmed[count / 2 | 0];
+  }
+  function Fit(slope, residualSigma) {
+    this.slope_1 = slope;
+    this.residualSigma_1 = residualSigma;
+  }
+  function fitSlope($this, frame, i, halfWidthM) {
+    var n = frame.get_size_woubt6_k$();
+    var s = frame.s_1;
+    var theta = frame.theta_1;
+    var si = s[i];
+    var ti = theta[i];
+    var lo = i;
+    while (lo > 0 && si - s[lo - 1 | 0] <= halfWidthM && (i - lo | 0) < 400) {
+      lo = lo - 1 | 0;
+    }
+    var hi = i;
+    while (hi < (n - 1 | 0) && s[hi + 1 | 0] - si <= halfWidthM && (hi - i | 0) < 400) {
+      hi = hi + 1 | 0;
+    }
+    var m = (hi - lo | 0) + 1 | 0;
+    if (m < 3)
+      return null;
+    var sumS = 0.0;
+    var sumSS = 0.0;
+    var sumT = 0.0;
+    var sumST = 0.0;
+    var inductionVariable = lo;
+    var last = hi;
+    if (inductionVariable <= last)
+      do {
+        var j = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var ds = s[j] - si;
+        var dt = theta[j] - ti;
+        sumS = sumS + ds;
+        sumSS = sumSS + ds * ds;
+        sumT = sumT + dt;
+        sumST = sumST + ds * dt;
+      }
+       while (!(j === last));
+    var mD = m;
+    var denominator = mD * sumSS - sumS * sumS;
+    if (denominator < 1.0E-6 * mD * halfWidthM * halfWidthM)
+      return null;
+    var slope = (mD * sumST - sumS * sumT) / denominator;
+    var intercept = (sumT - slope * sumS) / mD;
+    var rss = 0.0;
+    var inductionVariable_0 = lo;
+    var last_0 = hi;
+    if (inductionVariable_0 <= last_0)
+      do {
+        var j_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        var ds_0 = s[j_0] - si;
+        var residual = theta[j_0] - ti - intercept - slope * ds_0;
+        rss = rss + residual * residual;
+      }
+       while (!(j_0 === last_0));
+    // Inline function 'kotlin.math.sqrt' call
+    var x = rss / coerceAtLeast(mD - 2.0, 1.0);
+    var sigma = Math.sqrt(x);
+    return !isFinite(slope) || !isFinite(sigma) ? null : new Fit(slope, sigma);
+  }
+  function CurvatureEstimator() {
+    this.SCALE_RESIDUAL_FACTOR_1 = 2.0;
+    this.MAX_HALF_WINDOW_POINTS_1 = 400;
+    this.DEGENERACY_FACTOR_1 = 1.0E-6;
+  }
+  protoOf(CurvatureEstimator).computeHeadings_ev7p13_k$ = function (frame) {
+    var n = frame.get_size_woubt6_k$();
+    var theta = frame.theta_1;
+    if (n === 0)
+      return Unit_instance;
+    var previous = NaN;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var a = i > 0 ? i - 1 | 0 : 0;
+        var b = i < (n - 1 | 0) ? i + 1 | 0 : n - 1 | 0;
+        var dx = frame.x_1[b] - frame.x_1[a];
+        var dy = frame.y_1[b] - frame.y_1[a];
+        var tmp;
+        if (dx === 0.0 && dy === 0.0) {
+          tmp = isNaN_0(previous) ? 0.0 : previous;
+        } else {
+          // Inline function 'kotlin.math.atan2' call
+          tmp = Math.atan2(dy, dx);
+        }
+        var raw = tmp;
+        var tmp_0;
+        if (i === 0 || isNaN_0(previous)) {
+          tmp_0 = raw;
+        } else {
+          tmp_0 = previous + LocalFrame_instance.unwrap_i6c8al_k$(raw - previous);
+        }
+        theta[i] = tmp_0;
+        previous = theta[i];
+      }
+       while (inductionVariable < n);
+  };
+  protoOf(CurvatureEstimator).computeCurvature_emiphc_k$ = function (frame, windowsM, sigmaThetaRad, curvatureSmoothM) {
+    var n = frame.get_size_woubt6_k$();
+    var kappa = frame.kappa_1;
+    if (n === 0)
+      return Unit_instance;
+    // Inline function 'kotlin.collections.isNotEmpty' call
+    // Inline function 'kotlin.collections.isEmpty' call
+    // Inline function 'kotlin.require' call
+    if (!!(windowsM.length === 0)) {
+      var message = 'At least one curvature window is required';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    var scales = windowsM.length;
+    var slopes = new Float64Array(scales);
+    var sigmas = new Float64Array(scales);
+    var raw = new Float64Array(n);
+    var measuredNoise = medianSigma(this, frame, windowsM[scales - 1 | 0]);
+    // Inline function 'kotlin.comparisons.maxOf' call
+    var threshold = 2.0 * Math.max(sigmaThetaRad, measuredNoise);
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var inductionVariable_0 = 0;
+        if (inductionVariable_0 < scales)
+          do {
+            var w = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            var fit = fitSlope(this, frame, i, windowsM[w]);
+            var tmp1_elvis_lhs = fit == null ? null : fit.slope_1;
+            slopes[w] = tmp1_elvis_lhs == null ? NaN : tmp1_elvis_lhs;
+            var tmp3_elvis_lhs = fit == null ? null : fit.residualSigma_1;
+            sigmas[w] = tmp3_elvis_lhs == null ? NaN : tmp3_elvis_lhs;
+          }
+           while (inductionVariable_0 < scales);
+        var chosen = NaN;
+        var widest = NaN;
+        var inductionVariable_1 = scales - 1 | 0;
+        if (0 <= inductionVariable_1)
+          $l$loop_0: do {
+            var w_0 = inductionVariable_1;
+            inductionVariable_1 = inductionVariable_1 + -1 | 0;
+            if (isNaN_0(sigmas[w_0]))
+              continue $l$loop_0;
+            if (isNaN_0(widest))
+              widest = slopes[w_0];
+            if (sigmas[w_0] <= threshold) {
+              chosen = slopes[w_0];
+              break $l$loop_0;
+            }
+          }
+           while (0 <= inductionVariable_1);
+        var tmp;
+        if (!isNaN_0(chosen)) {
+          tmp = chosen;
+        } else if (!isNaN_0(widest)) {
+          tmp = widest;
+        } else {
+          tmp = 0.0;
+        }
+        raw[i] = tmp;
+      }
+       while (inductionVariable < n);
+    var smoothed = LocalFrame_instance.smooth_kce7pb_k$(raw, frame.s_1, curvatureSmoothM);
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = smoothed.length;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp_0 = smoothed;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    arrayCopy(tmp_0, kappa, 0, 0, endIndex);
+  };
+  protoOf(CurvatureEstimator).radiusAt_umgvjz_k$ = function (kappa) {
+    var tmp;
+    // Inline function 'kotlin.math.abs' call
+    if (Math.abs(kappa) < 1.0E-12) {
+      tmp = Infinity;
+    } else {
+      // Inline function 'kotlin.math.abs' call
+      tmp = 1.0 / Math.abs(kappa);
+    }
+    return tmp;
+  };
+  var CurvatureEstimator_instance;
+  function CurvatureEstimator_getInstance() {
+    return CurvatureEstimator_instance;
+  }
+  function LocalFrame() {
+    this.MAX_ABS_LATITUDE_RAD_1 = 1.4835298641951802;
+    this.MIN_POINTS_1 = 8;
+  }
+  protoOf(LocalFrame).project_n982lp_k$ = function (path, smoothWindowM) {
+    var n = path.size_1;
+    if (n < 8)
+      return null;
+    var bounds = path.boundsRad_1;
+    var lat0 = (bounds.minLat_1 + bounds.maxLat_1) / 2.0;
+    var lon0 = (bounds.minLon_1 + bounds.maxLon_1) / 2.0;
+    if (!isFinite(lat0) || !isFinite(lon0))
+      return null;
+    // Inline function 'kotlin.math.abs' call
+    if (Math.abs(lat0) > 1.4835298641951802)
+      return null;
+    if (bounds.maxLon_1 - bounds.minLon_1 > 3.141592653589793)
+      lon0 = path.longitude_a9xl_k$(0);
+    // Inline function 'kotlin.math.cos' call
+    var k = Math.cos(lat0);
+    var rawX = new Float64Array(n);
+    var rawY = new Float64Array(n);
+    var s = new Float64Array(n);
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var lat = path.latitude_gb4iok_k$(i);
+        var lon = path.longitude_a9xl_k$(i);
+        var dist = path.distance_5s4s77_k$(i);
+        if (!isFinite(lat) || !isFinite(lon) || !isFinite(dist))
+          return null;
+        var dLon = this.unwrap_i6c8al_k$(lon - lon0);
+        rawX[i] = 6371000.0 * k * dLon;
+        rawY[i] = 6371000.0 * (lat - lat0);
+        s[i] = dist;
+      }
+       while (inductionVariable < n);
+    var x = this.smooth_kce7pb_k$(rawX, s, smoothWindowM);
+    var y = this.smooth_kce7pb_k$(rawY, s, smoothWindowM);
+    this.arclengthOf_yiuhr5_k$(x, y, s);
+    return new PlanarFrame(x, y, s, new Float64Array(n), new Float64Array(n), lat0, lon0, k);
+  };
+  protoOf(LocalFrame).unproject_ym27oh_k$ = function (frame, x, y) {
+    var lat = frame.lat0__1 + y / 6371000.0;
+    var lon = frame.lon0__1 + x / (6371000.0 * frame.k_1);
+    // Inline function 'kotlin.doubleArrayOf' call
+    return new Float64Array([lat, lon]);
+  };
+  protoOf(LocalFrame).arclengthOf_yiuhr5_k$ = function (x, y, s) {
+    s[0] = 0.0;
+    var inductionVariable = 1;
+    var last = x.length;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var dx = x[i] - x[i - 1 | 0];
+        var dy = y[i] - y[i - 1 | 0];
+        var tmp = s[i - 1 | 0];
+        // Inline function 'kotlin.math.sqrt' call
+        var x_0 = dx * dx + dy * dy;
+        s[i] = tmp + Math.sqrt(x_0);
+      }
+       while (inductionVariable < last);
+  };
+  protoOf(LocalFrame).unwrap_i6c8al_k$ = function (a) {
+    return a - 2.0 * 3.141592653589793 * round(a / (2.0 * 3.141592653589793));
+  };
+  protoOf(LocalFrame).smooth_kce7pb_k$ = function (v, s, windowM) {
+    var n = v.length;
+    if (windowM <= 0.0 || n < 3) {
+      // Inline function 'kotlin.collections.copyOf' call
+      // Inline function 'kotlin.js.asDynamic' call
+      return v.slice();
+    }
+    var out = new Float64Array(n);
+    var lo = 0;
+    var hi = 0;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var c = s[i];
+        while (lo < i && c - s[lo] > windowM) {
+          lo = lo + 1 | 0;
+        }
+        if (hi < i)
+          hi = i;
+        while (hi < (n - 1 | 0) && s[hi + 1 | 0] - c <= windowM) {
+          hi = hi + 1 | 0;
+        }
+        var weightSum = 0.0;
+        var valueSum = 0.0;
+        var inductionVariable_0 = lo;
+        var last = hi;
+        if (inductionVariable_0 <= last)
+          $l$loop: do {
+            var j = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            // Inline function 'kotlin.math.abs' call
+            var x = s[j] - c;
+            var w = 1.0 - Math.abs(x) / windowM;
+            if (w <= 0.0)
+              continue $l$loop;
+            weightSum = weightSum + w;
+            valueSum = valueSum + v[j] * w;
+          }
+           while (!(j === last));
+        out[i] = weightSum > 0.0 ? valueSum / weightSum : v[i];
+      }
+       while (inductionVariable < n);
+    return out;
+  };
+  var LocalFrame_instance;
+  function LocalFrame_getInstance() {
+    return LocalFrame_instance;
+  }
+  function Companion_11() {
+  }
+  protoOf(Companion_11).assemble_miimn7_k$ = function (frame, center, rho, steeringLengthM, centeringLengthM) {
+    var n = frame.get_size_woubt6_k$();
+    var h0 = new Float64Array(n);
+    var h1 = new Float64Array(n);
+    var h2 = new Float64Array(n);
+    var linear = new Float64Array(n);
+    var constant = 0.0;
+    var lambdaR = 1.0 / (steeringLengthM * steeringLengthM);
+    var lambdaC = 1.0 / (centeringLengthM * centeringLengthM * centeringLengthM * centeringLengthM);
+    var a = new Float64Array(3);
+    var b = new Float64Array(3);
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      $l$loop_0: do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var hMinus = i >= 1 ? frame.s_1[i] - frame.s_1[i - 1 | 0] : 0.0;
+        var hPlus = (i + 1 | 0) < n ? frame.s_1[i + 1 | 0] - frame.s_1[i] : 0.0;
+        var weight = 0.5 * (hMinus + hPlus);
+        h0[i] = h0[i] + 2.0 * weight * lambdaC;
+        linear[i] = linear[i] - 2.0 * weight * lambdaC * center[i];
+        constant = constant + weight * lambdaC * center[i] * center[i];
+        if (i < 1 || (i + 1 | 0) >= n)
+          continue $l$loop_0;
+        var denom = hPlus * hMinus * (hPlus + hMinus);
+        if (denom <= 0.0)
+          continue $l$loop_0;
+        a[0] = 2.0 * hPlus / denom;
+        a[1] = -2.0 * (hPlus + hMinus) / denom + frame.kappa_1[i] * frame.kappa_1[i];
+        a[2] = 2.0 * hMinus / denom;
+        b[0] = -hPlus * hPlus / denom;
+        b[1] = (hPlus * hPlus - hMinus * hMinus) / denom;
+        b[2] = hMinus * hMinus / denom;
+        var wRho = weight * rho[i];
+        var wR = weight * lambdaR;
+        var kappaI = frame.kappa_1[i];
+        var inductionVariable_0 = 0;
+        if (inductionVariable_0 <= 2)
+          do {
+            var p = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            var row = (i - 1 | 0) + p | 0;
+            linear[row] = linear[row] + 2.0 * wRho * kappaI * a[p];
+            var inductionVariable_1 = p;
+            if (inductionVariable_1 <= 2)
+              do {
+                var q = inductionVariable_1;
+                inductionVariable_1 = inductionVariable_1 + 1 | 0;
+                var col = (i - 1 | 0) + q | 0;
+                var contribution = 2.0 * (wRho * a[p] * a[q] + wR * b[p] * b[q]);
+                switch (col - row | 0) {
+                  case 0:
+                    h0[row] = h0[row] + contribution;
+                    break;
+                  case 1:
+                    h1[row] = h1[row] + contribution;
+                    break;
+                  case 2:
+                    h2[row] = h2[row] + contribution;
+                    break;
+                }
+              }
+               while (inductionVariable_1 <= 2);
+          }
+           while (inductionVariable_0 <= 2);
+        constant = constant + wRho * kappaI * kappaI;
+      }
+       while (inductionVariable < n);
+    return new OffsetEnergy(h0, h1, h2, linear, constant);
+  };
+  var Companion_instance_12;
+  function Companion_getInstance_14() {
+    return Companion_instance_12;
+  }
+  function OffsetEnergy(h0, h1, h2, linear, constant) {
+    this.h0__1 = h0;
+    this.h1__1 = h1;
+    this.h2__1 = h2;
+    this.linear_1 = linear;
+    this.constant_1 = constant;
+  }
+  protoOf(OffsetEnergy).get_size_woubt6_k$ = function () {
+    return this.h0__1.length;
+  };
+  protoOf(OffsetEnergy).value_6wg803_k$ = function (n, scratch) {
+    BandedLdl_instance.multiply_dwj15t_k$(this.h0__1, this.h1__1, this.h2__1, n, scratch);
+    var acc = this.constant_1;
+    var inductionVariable = 0;
+    var last = n.length - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        acc = acc + (0.5 * scratch[i] * n[i] + this.linear_1[i] * n[i]);
+      }
+       while (inductionVariable <= last);
+    return acc;
+  };
+  protoOf(OffsetEnergy).gradient_zecmby_k$ = function (n, out) {
+    BandedLdl_instance.multiply_dwj15t_k$(this.h0__1, this.h1__1, this.h2__1, n, out);
+    var inductionVariable = 0;
+    var last = out.length - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        out[i] = out[i] + this.linear_1[i];
+      }
+       while (inductionVariable <= last);
+  };
+  function QpResult(offset, iterations, gradientInfNorm, converged, activeConstraints) {
+    this.offset_1 = offset;
+    this.iterations_1 = iterations;
+    this.gradientInfNorm_1 = gradientInfNorm;
+    this.converged_1 = converged;
+    this.activeConstraints_1 = activeConstraints;
+  }
+  function isFree($this, x, lo, hi, g, epsilon) {
+    if (hi - lo <= 2.0 * epsilon)
+      return false;
+    if (x <= lo + epsilon && g > 0.0)
+      return false;
+    if (x >= hi - epsilon && g < 0.0)
+      return false;
+    return true;
+  }
+  function buildFreeSystem($this, energy, freeIndex, freeCount, f0, f1, f2) {
+    var inductionVariable = 0;
+    if (inductionVariable < freeCount)
+      do {
+        var p = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var i = freeIndex[p];
+        f0[p] = energy.h0__1[i];
+        f1[p] = 0.0;
+        f2[p] = 0.0;
+        if ((p + 1 | 0) < freeCount) {
+          var tmp0_subject = freeIndex[p + 1 | 0] - i | 0;
+          if (tmp0_subject === 1) {
+            f1[p] = energy.h1__1[i];
+          } else if (tmp0_subject === 2) {
+            f1[p] = energy.h2__1[i];
+          }
+        }
+        if ((p + 2 | 0) < freeCount && (freeIndex[p + 2 | 0] - i | 0) === 2) {
+          f2[p] = energy.h2__1[i];
+        }
+      }
+       while (inductionVariable < freeCount);
+  }
+  function OffsetQp() {
+    this.ARMIJO_C1__1 = 1.0E-4;
+    this.MAX_BACKTRACKS_1 = 20;
+  }
+  protoOf(OffsetQp).solve_j37bz7_k$ = function (energy, lo, hi, seed, maxIterations, gradientTolerance, boundEpsilonM) {
+    var n = energy.get_size_woubt6_k$();
+    var tmp = 0;
+    var tmp_0 = new Float64Array(n);
+    while (tmp < n) {
+      var tmp_1 = tmp;
+      tmp_0[tmp_1] = coerceIn(seed[tmp_1], lo[tmp_1], hi[tmp_1]);
+      tmp = tmp + 1 | 0;
+    }
+    var x = tmp_0;
+    var g = new Float64Array(n);
+    var scratch = new Float64Array(n);
+    var direction = new Float64Array(n);
+    var candidate = new Float64Array(n);
+    energy.gradient_zecmby_k$(x, g);
+    var referenceGradient = 0.0;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp_2;
+        if (isFree(this, x[i], lo[i], hi[i], g[i], boundEpsilonM)) {
+          // Inline function 'kotlin.math.abs' call
+          var x_0 = g[i];
+          tmp_2 = Math.abs(x_0) > referenceGradient;
+        } else {
+          tmp_2 = false;
+        }
+        if (tmp_2) {
+          // Inline function 'kotlin.math.abs' call
+          var x_1 = g[i];
+          referenceGradient = Math.abs(x_1);
+        }
+      }
+       while (inductionVariable < n);
+    if (referenceGradient <= 0.0)
+      referenceGradient = 1.0;
+    var iterations = 0;
+    var converged = false;
+    var relativeResidual = 0.0;
+    var freeIndex = new Int32Array(n);
+    var f0 = new Float64Array(n);
+    var f1 = new Float64Array(n);
+    var f2 = new Float64Array(n);
+    var rhs = new Float64Array(n);
+    $l$loop_3: while (iterations < maxIterations) {
+      energy.gradient_zecmby_k$(x, g);
+      var freeCount = 0;
+      var residual = 0.0;
+      var inductionVariable_0 = 0;
+      if (inductionVariable_0 < n)
+        do {
+          var i_0 = inductionVariable_0;
+          inductionVariable_0 = inductionVariable_0 + 1 | 0;
+          if (isFree(this, x[i_0], lo[i_0], hi[i_0], g[i_0], boundEpsilonM)) {
+            var _unary__edvuaz = freeCount;
+            freeCount = _unary__edvuaz + 1 | 0;
+            freeIndex[_unary__edvuaz] = i_0;
+            // Inline function 'kotlin.math.abs' call
+            var x_2 = g[i_0];
+            if (Math.abs(x_2) > residual) {
+              // Inline function 'kotlin.math.abs' call
+              var x_3 = g[i_0];
+              residual = Math.abs(x_3);
+            }
+          }
+        }
+         while (inductionVariable_0 < n);
+      relativeResidual = residual / referenceGradient;
+      if (freeCount === 0 || relativeResidual <= gradientTolerance) {
+        converged = true;
+        break $l$loop_3;
+      }
+      buildFreeSystem(this, energy, freeIndex, freeCount, f0, f1, f2);
+      var fa0 = copyOf(f0, freeCount);
+      var fa1 = copyOf(f1, freeCount);
+      var fa2 = copyOf(f2, freeCount);
+      if (!BandedLdl_instance.factor_n459o6_k$(fa0, fa1, fa2)) {
+        break $l$loop_3;
+      }
+      var inductionVariable_1 = 0;
+      var last = freeCount;
+      if (inductionVariable_1 < last)
+        do {
+          var p = inductionVariable_1;
+          inductionVariable_1 = inductionVariable_1 + 1 | 0;
+          rhs[p] = -g[freeIndex[p]];
+        }
+         while (inductionVariable_1 < last);
+      BandedLdl_instance.solveInPlace_jrw92v_k$(fa0, fa1, fa2, rhs);
+      var inductionVariable_2 = 0;
+      if (inductionVariable_2 < n)
+        do {
+          var i_1 = inductionVariable_2;
+          inductionVariable_2 = inductionVariable_2 + 1 | 0;
+          direction[i_1] = 0.0;
+        }
+         while (inductionVariable_2 < n);
+      var inductionVariable_3 = 0;
+      var last_0 = freeCount;
+      if (inductionVariable_3 < last_0)
+        do {
+          var p_0 = inductionVariable_3;
+          inductionVariable_3 = inductionVariable_3 + 1 | 0;
+          direction[freeIndex[p_0]] = rhs[p_0];
+        }
+         while (inductionVariable_3 < last_0);
+      var directionalDerivative = 0.0;
+      var inductionVariable_4 = 0;
+      var last_1 = freeCount;
+      if (inductionVariable_4 < last_1)
+        do {
+          var p_1 = inductionVariable_4;
+          inductionVariable_4 = inductionVariable_4 + 1 | 0;
+          var i_2 = freeIndex[p_1];
+          directionalDerivative = directionalDerivative + g[i_2] * direction[i_2];
+        }
+         while (inductionVariable_4 < last_1);
+      if (directionalDerivative >= 0.0)
+        break $l$loop_3;
+      var current = energy.value_6wg803_k$(x, scratch);
+      var step = 1.0;
+      var accepted = false;
+      var inductionVariable_5 = 0;
+      if (inductionVariable_5 < 20)
+        $l$loop_2: do {
+          var attempt = inductionVariable_5;
+          inductionVariable_5 = inductionVariable_5 + 1 | 0;
+          var inductionVariable_6 = 0;
+          if (inductionVariable_6 < n)
+            do {
+              var i_3 = inductionVariable_6;
+              inductionVariable_6 = inductionVariable_6 + 1 | 0;
+              candidate[i_3] = coerceIn(x[i_3] + step * direction[i_3], lo[i_3], hi[i_3]);
+            }
+             while (inductionVariable_6 < n);
+          var trial = energy.value_6wg803_k$(candidate, scratch);
+          if (trial <= current + 1.0E-4 * step * directionalDerivative) {
+            accepted = true;
+            break $l$loop_2;
+          }
+          step = step / 2.0;
+        }
+         while (inductionVariable_5 < 20);
+      if (!accepted)
+        break $l$loop_3;
+      // Inline function 'kotlin.collections.copyInto' call
+      var endIndex = candidate.length;
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var tmp_3 = candidate;
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      arrayCopy(tmp_3, x, 0, 0, endIndex);
+      iterations = iterations + 1 | 0;
+    }
+    var active = 0;
+    var inductionVariable_7 = 0;
+    if (inductionVariable_7 < n)
+      do {
+        var i_4 = inductionVariable_7;
+        inductionVariable_7 = inductionVariable_7 + 1 | 0;
+        if (x[i_4] <= lo[i_4] + boundEpsilonM || x[i_4] >= hi[i_4] - boundEpsilonM) {
+          active = active + 1 | 0;
+        }
+      }
+       while (inductionVariable_7 < n);
+    return new QpResult(x, iterations, relativeResidual, converged, active);
+  };
+  var OffsetQp_instance;
+  function OffsetQp_getInstance() {
+    return OffsetQp_instance;
+  }
+  function Companion_12() {
+    Companion_instance_13 = this;
+    this.DEFAULT_1 = new CurvatureOptions();
+  }
+  var Companion_instance_13;
+  function Companion_getInstance_15() {
+    if (Companion_instance_13 == null)
+      new Companion_12();
+    return Companion_instance_13;
+  }
+  function CurvatureOptions(enabled, geometrySmoothWindowM, curvatureWindowsM, headingNoiseRad, curvatureSmoothWindowM) {
+    Companion_getInstance_15();
+    enabled = enabled === VOID ? true : enabled;
+    geometrySmoothWindowM = geometrySmoothWindowM === VOID ? 3.0 : geometrySmoothWindowM;
+    curvatureWindowsM = curvatureWindowsM === VOID ? listOf_0([3.0, 6.0, 12.0, 25.0]) : curvatureWindowsM;
+    headingNoiseRad = headingNoiseRad === VOID ? 0.05 : headingNoiseRad;
+    curvatureSmoothWindowM = curvatureSmoothWindowM === VOID ? 3.0 : curvatureSmoothWindowM;
+    this.enabled_1 = enabled;
+    this.geometrySmoothWindowM_1 = geometrySmoothWindowM;
+    this.curvatureWindowsM_1 = curvatureWindowsM;
+    this.headingNoiseRad_1 = headingNoiseRad;
+    this.curvatureSmoothWindowM_1 = curvatureSmoothWindowM;
+    // Inline function 'kotlin.require' call
+    if (!(this.geometrySmoothWindowM_1 >= 0.0)) {
+      var message = 'geometrySmoothWindowM must be >= 0';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.collections.isNotEmpty' call
+    // Inline function 'kotlin.require' call
+    if (!!this.curvatureWindowsM_1.isEmpty_y1axqb_k$()) {
+      var message_0 = 'at least one curvature window is required';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    var tmp0 = this.curvatureWindowsM_1;
+    var tmp$ret$5;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.all' call
+      var tmp;
+      if (isInterface(tmp0, Collection)) {
+        tmp = tmp0.isEmpty_y1axqb_k$();
+      } else {
+        tmp = false;
+      }
+      if (tmp) {
+        tmp$ret$5 = true;
+        break $l$block_0;
+      }
+      var _iterator__ex2g4s = tmp0.iterator_jk1svi_k$();
+      while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
+        var element = _iterator__ex2g4s.next_20eer_k$();
+        if (!(element > 0.0)) {
+          tmp$ret$5 = false;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$5 = true;
+    }
+    // Inline function 'kotlin.require' call
+    if (!tmp$ret$5) {
+      var message_1 = 'curvature windows must be positive';
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+    var tmp0_0 = zipWithNext(this.curvatureWindowsM_1);
+    var tmp$ret$9;
+    $l$block_2: {
+      // Inline function 'kotlin.collections.all' call
+      var tmp_0;
+      if (isInterface(tmp0_0, Collection)) {
+        tmp_0 = tmp0_0.isEmpty_y1axqb_k$();
+      } else {
+        tmp_0 = false;
+      }
+      if (tmp_0) {
+        tmp$ret$9 = true;
+        break $l$block_2;
+      }
+      var _iterator__ex2g4s_0 = tmp0_0.iterator_jk1svi_k$();
+      while (_iterator__ex2g4s_0.hasNext_bitz1p_k$()) {
+        var element_0 = _iterator__ex2g4s_0.next_20eer_k$();
+        var a = element_0.component1_7eebsc_k$();
+        var b = element_0.component2_7eebsb_k$();
+        if (!(a < b)) {
+          tmp$ret$9 = false;
+          break $l$block_2;
+        }
+      }
+      tmp$ret$9 = true;
+    }
+    // Inline function 'kotlin.require' call
+    if (!tmp$ret$9) {
+      var message_2 = 'curvature windows must be strictly ascending: ' + toString(this.curvatureWindowsM_1);
+      throw IllegalArgumentException_init_$Create$(toString(message_2));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.headingNoiseRad_1 > 0.0)) {
+      var message_3 = 'headingNoiseRad must be positive';
+      throw IllegalArgumentException_init_$Create$(toString(message_3));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.curvatureSmoothWindowM_1 >= 0.0)) {
+      var message_4 = 'curvatureSmoothWindowM must be >= 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_4));
+    }
+  }
+  protoOf(CurvatureOptions).copy_8k70ek_k$ = function (enabled, geometrySmoothWindowM, curvatureWindowsM, headingNoiseRad, curvatureSmoothWindowM) {
+    return new CurvatureOptions(enabled, geometrySmoothWindowM, curvatureWindowsM, headingNoiseRad, curvatureSmoothWindowM);
+  };
+  protoOf(CurvatureOptions).copy$default_7y8gcg_k$ = function (enabled, geometrySmoothWindowM, curvatureWindowsM, headingNoiseRad, curvatureSmoothWindowM, $super) {
+    enabled = enabled === VOID ? this.enabled_1 : enabled;
+    geometrySmoothWindowM = geometrySmoothWindowM === VOID ? this.geometrySmoothWindowM_1 : geometrySmoothWindowM;
+    curvatureWindowsM = curvatureWindowsM === VOID ? this.curvatureWindowsM_1 : curvatureWindowsM;
+    headingNoiseRad = headingNoiseRad === VOID ? this.headingNoiseRad_1 : headingNoiseRad;
+    curvatureSmoothWindowM = curvatureSmoothWindowM === VOID ? this.curvatureSmoothWindowM_1 : curvatureSmoothWindowM;
+    return $super === VOID ? this.copy_8k70ek_k$(enabled, geometrySmoothWindowM, curvatureWindowsM, headingNoiseRad, curvatureSmoothWindowM) : $super.copy_8k70ek_k$.call(this, enabled, geometrySmoothWindowM, curvatureWindowsM, headingNoiseRad, curvatureSmoothWindowM);
+  };
+  protoOf(CurvatureOptions).toString = function () {
+    return 'CurvatureOptions(enabled=' + this.enabled_1 + ', geometrySmoothWindowM=' + this.geometrySmoothWindowM_1 + ', curvatureWindowsM=' + toString(this.curvatureWindowsM_1) + ', headingNoiseRad=' + this.headingNoiseRad_1 + ', curvatureSmoothWindowM=' + this.curvatureSmoothWindowM_1 + ')';
+  };
+  protoOf(CurvatureOptions).hashCode = function () {
+    var result = getBooleanHashCode(this.enabled_1);
+    result = imul(result, 31) + getNumberHashCode(this.geometrySmoothWindowM_1) | 0;
+    result = imul(result, 31) + hashCode(this.curvatureWindowsM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.headingNoiseRad_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.curvatureSmoothWindowM_1) | 0;
+    return result;
+  };
+  protoOf(CurvatureOptions).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CurvatureOptions))
+      return false;
+    if (!(this.enabled_1 === other.enabled_1))
+      return false;
+    if (!equals(this.geometrySmoothWindowM_1, other.geometrySmoothWindowM_1))
+      return false;
+    if (!equals(this.curvatureWindowsM_1, other.curvatureWindowsM_1))
+      return false;
+    if (!equals(this.headingNoiseRad_1, other.headingNoiseRad_1))
+      return false;
+    if (!equals(this.curvatureSmoothWindowM_1, other.curvatureSmoothWindowM_1))
+      return false;
+    return true;
+  };
+  function PathCurvature() {
+  }
+  protoOf(PathCurvature).compute_s9yd16_k$ = function (path, options) {
+    if (!options.enabled_1)
+      return false;
+    var tmp0_elvis_lhs = LocalFrame_instance.project_n982lp_k$(path, options.geometrySmoothWindowM_1);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return false;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var frame = tmp;
+    CurvatureEstimator_instance.computeHeadings_ev7p13_k$(frame);
+    CurvatureEstimator_instance.computeCurvature_emiphc_k$(frame, toDoubleArray(options.curvatureWindowsM_1), options.headingNoiseRad_1, options.curvatureSmoothWindowM_1);
+    var inductionVariable = 0;
+    var last = path.size_1;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        path.setTrajectoryCurvature_yjmp8s_k$(i, frame.kappa_1[i]);
+      }
+       while (inductionVariable < last);
+    return true;
+  };
+  var PathCurvature_instance;
+  function PathCurvature_getInstance() {
+    return PathCurvature_instance;
+  }
+  function PlanarFrame(x, y, s, theta, kappa, lat0, lon0, k) {
+    this.x_1 = x;
+    this.y_1 = y;
+    this.s_1 = s;
+    this.theta_1 = theta;
+    this.kappa_1 = kappa;
+    this.lat0__1 = lat0;
+    this.lon0__1 = lon0;
+    this.k_1 = k;
+  }
+  protoOf(PlanarFrame).get_size_woubt6_k$ = function () {
+    return this.x_1.length;
+  };
+  function RacingLineReport(size, corners, centerlineCurvature, corridorLo, corridorHi, roadHalfWidthM, lateralOffsetM, trajectoryCurvature, newtonIterations, relativeGradient, converged, activeConstraints) {
+    this.size_1 = size;
+    this.corners_1 = corners;
+    this.centerlineCurvature_1 = centerlineCurvature;
+    this.corridorLo_1 = corridorLo;
+    this.corridorHi_1 = corridorHi;
+    this.roadHalfWidthM_1 = roadHalfWidthM;
+    this.lateralOffsetM_1 = lateralOffsetM;
+    this.trajectoryCurvature_1 = trajectoryCurvature;
+    this.newtonIterations_1 = newtonIterations;
+    this.relativeGradient_1 = relativeGradient;
+    this.converged_1 = converged;
+    this.activeConstraints_1 = activeConstraints;
+  }
+  protoOf(RacingLineReport).get_maxCorridorWidthM_7bycoc_k$ = function () {
+    var m = 0.0;
+    var inductionVariable = 0;
+    var last = this.size_1;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var w = this.corridorHi_1[i] - this.corridorLo_1[i];
+        if (w > m)
+          m = w;
+      }
+       while (inductionVariable < last);
+    return m;
+  };
+  function project($this, path, options) {
+    var tmp0_elvis_lhs = LocalFrame_instance.project_n982lp_k$(path, options.curvature_1.geometrySmoothWindowM_1);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return null;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var frame = tmp;
+    CurvatureEstimator_instance.computeHeadings_ev7p13_k$(frame);
+    CurvatureEstimator_instance.computeCurvature_emiphc_k$(frame, toDoubleArray(options.curvature_1.curvatureWindowsM_1), options.curvature_1.headingNoiseRad_1, options.curvature_1.curvatureSmoothWindowM_1);
+    return frame;
+  }
+  function analyzeFrame($this, path, frame, options) {
+    var width = Corridor_instance.resolveWidth_feg61f_k$(path, frame, options);
+    var corners = CornerDetector_instance.detect_cq5dkx_k$(frame, options, width);
+    var bounds = Corridor_instance.build_fyfb0s_k$(frame, width, options);
+    var tmp = 0;
+    var tmp_0 = frame.get_size_woubt6_k$();
+    var tmp_1 = new Float64Array(tmp_0);
+    while (tmp < tmp_0) {
+      var tmp_2 = tmp;
+      tmp_1[tmp_2] = coerceIn(0.0, bounds.lo_1[tmp_2], bounds.hi_1[tmp_2]);
+      tmp = tmp + 1 | 0;
+    }
+    var center = tmp_1;
+    var objectiveKappa = 1.0 / options.objectiveRadiusM_1;
+    var tmp_3 = 0;
+    var tmp_4 = frame.get_size_woubt6_k$();
+    var tmp_5 = new Float64Array(tmp_4);
+    while (tmp_3 < tmp_4) {
+      var tmp_6 = tmp_3;
+      var tmp_7;
+      // Inline function 'kotlin.math.abs' call
+      var x = frame.kappa_1[tmp_6];
+      if (Math.abs(x) > objectiveKappa) {
+        tmp_7 = 1.0;
+      } else {
+        tmp_7 = 0.0;
+      }
+      tmp_5[tmp_6] = tmp_7;
+      tmp_3 = tmp_3 + 1 | 0;
+    }
+    var rho = tmp_5;
+    var energy = Companion_instance_12.assemble_miimn7_k$(frame, center, rho, options.steeringLengthM_1, options.centeringLengthM_1);
+    var seed = center;
+    var solved = OffsetQp_instance.solve_j37bz7_k$(energy, bounds.lo_1, bounds.hi_1, seed, options.maxNewtonIterations_1, options.gradientTolerance_1, options.boundEpsilonM_1);
+    var trajectoryCurvature = measureOffsetCurvature($this, frame, solved.offset_1, options);
+    var tmp_8 = frame.get_size_woubt6_k$();
+    // Inline function 'kotlin.collections.copyOf' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp$ret$3 = frame.kappa_1.slice();
+    return new RacingLineReport(tmp_8, corners, tmp$ret$3, bounds.lo_1, bounds.hi_1, bounds.halfWidthM_1, solved.offset_1, trajectoryCurvature, solved.iterations_1, solved.gradientInfNorm_1, solved.converged_1, solved.activeConstraints_1);
+  }
+  function measureOffsetCurvature($this, frame, offset, options) {
+    var size = frame.get_size_woubt6_k$();
+    var x = new Float64Array(size);
+    var y = new Float64Array(size);
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp = frame.x_1[i];
+        var tmp_0 = offset[i];
+        // Inline function 'kotlin.math.sin' call
+        var x_0 = frame.theta_1[i];
+        x[i] = tmp - tmp_0 * Math.sin(x_0);
+        var tmp_1 = frame.y_1[i];
+        var tmp_2 = offset[i];
+        // Inline function 'kotlin.math.cos' call
+        var x_1 = frame.theta_1[i];
+        y[i] = tmp_1 + tmp_2 * Math.cos(x_1);
+      }
+       while (inductionVariable < size);
+    var s = new Float64Array(size);
+    LocalFrame_instance.arclengthOf_yiuhr5_k$(x, y, s);
+    var line = new PlanarFrame(x, y, s, new Float64Array(size), new Float64Array(size), frame.lat0__1, frame.lon0__1, frame.k_1);
+    CurvatureEstimator_instance.computeHeadings_ev7p13_k$(line);
+    CurvatureEstimator_instance.computeCurvature_emiphc_k$(line, toDoubleArray(options.curvature_1.curvatureWindowsM_1), options.curvature_1.headingNoiseRad_1, options.curvature_1.curvatureSmoothWindowM_1);
+    return line.kappa_1;
+  }
+  function RacingLine() {
+  }
+  protoOf(RacingLine).analyze_ikwae4_k$ = function (path, options) {
+    var tmp0_elvis_lhs = project(this, path, options);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return null;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var frame = tmp;
+    return analyzeFrame(this, path, frame, options);
+  };
+  protoOf(RacingLine).compute_uyx32p_k$ = function (source, options) {
+    var tmp0_elvis_lhs = project(this, source, options);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return source.copy_1tks5_k$();
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var frame = tmp;
+    var report = analyzeFrame(this, source, frame, options);
+    var out = new Path(source.size_1);
+    var inductionVariable = 0;
+    var last = source.size_1;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var _iterator__ex2g4s = get_entries().iterator_jk1svi_k$();
+        while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
+          var field = _iterator__ex2g4s.next_20eer_k$();
+          out.set_b3ze83_k$(i, field, source.get_z3le6l_k$(i, field));
+        }
+      }
+       while (inductionVariable < last);
+    var inductionVariable_0 = 0;
+    var last_0 = source.size_1;
+    if (inductionVariable_0 < last_0)
+      do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        var n = report.lateralOffsetM_1[i_0];
+        // Inline function 'kotlin.math.sin' call
+        var x = frame.theta_1[i_0];
+        var nx = -Math.sin(x);
+        // Inline function 'kotlin.math.cos' call
+        var x_0 = frame.theta_1[i_0];
+        var ny = Math.cos(x_0);
+        var x_1 = frame.x_1[i_0] + n * nx;
+        var y = frame.y_1[i_0] + n * ny;
+        out.setSourceLatitude_jzh9ix_k$(i_0, source.latitude_gb4iok_k$(i_0));
+        out.setSourceLongitude_xmvvyo_k$(i_0, source.longitude_a9xl_k$(i_0));
+        var latLon = LocalFrame_instance.unproject_ym27oh_k$(frame, x_1, y);
+        out.setLatitude_skkzf0_k$(i_0, latLon[0]);
+        out.setLongitude_k0bc8l_k$(i_0, latLon[1]);
+        out.setLateralOffset_k5uegq_k$(i_0, n);
+        out.setTrajectoryCurvature_yjmp8s_k$(i_0, report.trajectoryCurvature_1[i_0]);
+        out.setRoadWidth_g0vcte_k$(i_0, source.roadWidth_7zv9qq_k$(i_0));
+      }
+       while (inductionVariable_0 < last_0);
+    out.computeDerivedData_uoxpeo_k$();
+    PathCurvature_instance.compute_s9yd16_k$(out, options.curvature_1.copy$default_7y8gcg_k$(true));
+    return out;
+  };
+  var RacingLine_instance;
+  function RacingLine_getInstance() {
+    return RacingLine_instance;
+  }
+  function CorridorMode$Companion$byId$lambda(it) {
+    return it.get_id_kntnx8_k$();
+  }
+  var static_init_called_1;
+  function static_init_1() {
+    if (static_init_called_1)
+      return Unit_instance;
+    static_init_called_1 = true;
+    CorridorMode_LANE_instance = new CorridorMode('LANE', 0);
+    CorridorMode_LANE_LEFT_instance = new CorridorMode('LANE_LEFT', 1);
+    CorridorMode_FULL_ROAD_instance = new CorridorMode('FULL_ROAD', 2);
+    if (Companion_instance_14 == null) {
+      Companion_instance;
+      new Companion_13();
+    }
+  }
+  var CorridorMode_LANE_instance;
+  var CorridorMode_LANE_LEFT_instance;
+  var CorridorMode_FULL_ROAD_instance;
+  function Companion_13() {
+  }
+  protoOf(Companion_13).byId_8gmd94_k$ = function (name) {
+    var tmp0 = get_entries_2();
+    var tmp$ret$0;
+    $l$block: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s = tmp0.iterator_jk1svi_k$();
+      while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
+        var element = _iterator__ex2g4s.next_20eer_k$();
+        if (equals_0(element.get_id_kntnx8_k$(), name, true) || equals_0(element.name_1, name, true)) {
+          tmp$ret$0 = element;
+          break $l$block;
+        }
+      }
+      tmp$ret$0 = null;
+    }
+    var tmp0_elvis_lhs = tmp$ret$0;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      var tmp_0 = get_entries_2();
+      throw IllegalArgumentException_init_$Create$("Unknown corridor '" + name + "': expected one of " + joinToString(tmp_0, ', ', VOID, VOID, VOID, VOID, CorridorMode$Companion$byId$lambda));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  };
+  var Companion_instance_14;
+  function Companion_getInstance_16() {
+    return Companion_instance_14;
+  }
+  function values_1() {
+    static_init_1();
+    return [CorridorMode_LANE_getInstance(), CorridorMode_LANE_LEFT_getInstance(), CorridorMode_FULL_ROAD_getInstance()];
+  }
+  function get_entries_2() {
+    static_init_1();
+    if ($ENTRIES_1 == null)
+      $ENTRIES_1 = enumEntries(values_1());
+    return $ENTRIES_1;
+  }
+  var $ENTRIES_1;
+  function CorridorMode(name, ordinal) {
+    Enum.call(this, name, ordinal);
+  }
+  protoOf(CorridorMode).get_id_kntnx8_k$ = function () {
+    var tmp;
+    switch (this.ordinal_1) {
+      case 0:
+        tmp = 'lane';
+        break;
+      case 1:
+        tmp = 'lane-left';
+        break;
+      case 2:
+        tmp = 'full-road';
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+    return tmp;
+  };
+  var static_init_called_2;
+  function static_init_2() {
+    if (static_init_called_2)
+      return Unit_instance;
+    static_init_called_2 = true;
+    CornerKind_GENTLE_instance = new CornerKind('GENTLE', 0);
+    CornerKind_CORNER_instance = new CornerKind('CORNER', 1);
+    CornerKind_HAIRPIN_instance = new CornerKind('HAIRPIN', 2);
+  }
+  var CornerKind_GENTLE_instance;
+  var CornerKind_CORNER_instance;
+  var CornerKind_HAIRPIN_instance;
+  function CornerKind(name, ordinal) {
+    Enum.call(this, name, ordinal);
+  }
+  function Companion_14() {
+    Companion_instance_15 = this;
+    this.DEFAULT_1 = new RacingLineOptions();
+  }
+  var Companion_instance_15;
+  function Companion_getInstance_17() {
+    if (Companion_instance_15 == null)
+      new Companion_14();
+    return Companion_instance_15;
+  }
+  function RacingLineOptions(enabled, defaultRoadWidthM, edgeMarginM, corridor, cornerEnterRadiusM, cornerExitRadiusM, minCornerLengthM, minCornerTurnDeg, hairpinTurnDeg, gentleRadiusM, regularityFactor, selfProximityGapM, straightRunM, straightRadiusM, widthSmoothWindowM, objectiveRadiusM, steeringLengthM, centeringLengthM, maxNewtonIterations, gradientTolerance, boundEpsilonM, curvature, simplifyToleranceCapM) {
+    Companion_getInstance_17();
+    enabled = enabled === VOID ? false : enabled;
+    defaultRoadWidthM = defaultRoadWidthM === VOID ? 6.0 : defaultRoadWidthM;
+    edgeMarginM = edgeMarginM === VOID ? 0.5 : edgeMarginM;
+    corridor = corridor === VOID ? CorridorMode_LANE_getInstance() : corridor;
+    cornerEnterRadiusM = cornerEnterRadiusM === VOID ? 120.0 : cornerEnterRadiusM;
+    cornerExitRadiusM = cornerExitRadiusM === VOID ? 250.0 : cornerExitRadiusM;
+    minCornerLengthM = minCornerLengthM === VOID ? 8.0 : minCornerLengthM;
+    minCornerTurnDeg = minCornerTurnDeg === VOID ? 8.0 : minCornerTurnDeg;
+    hairpinTurnDeg = hairpinTurnDeg === VOID ? 150.0 : hairpinTurnDeg;
+    gentleRadiusM = gentleRadiusM === VOID ? 100.0 : gentleRadiusM;
+    regularityFactor = regularityFactor === VOID ? 0.85 : regularityFactor;
+    selfProximityGapM = selfProximityGapM === VOID ? 60.0 : selfProximityGapM;
+    straightRunM = straightRunM === VOID ? 150.0 : straightRunM;
+    straightRadiusM = straightRadiusM === VOID ? 500.0 : straightRadiusM;
+    widthSmoothWindowM = widthSmoothWindowM === VOID ? 20.0 : widthSmoothWindowM;
+    objectiveRadiusM = objectiveRadiusM === VOID ? 200.0 : objectiveRadiusM;
+    steeringLengthM = steeringLengthM === VOID ? 20.0 : steeringLengthM;
+    centeringLengthM = centeringLengthM === VOID ? 60.0 : centeringLengthM;
+    maxNewtonIterations = maxNewtonIterations === VOID ? 200 : maxNewtonIterations;
+    gradientTolerance = gradientTolerance === VOID ? 1.0E-8 : gradientTolerance;
+    boundEpsilonM = boundEpsilonM === VOID ? 1.0E-6 : boundEpsilonM;
+    curvature = curvature === VOID ? Companion_getInstance_15().DEFAULT_1 : curvature;
+    simplifyToleranceCapM = simplifyToleranceCapM === VOID ? 2.0 : simplifyToleranceCapM;
+    this.enabled_1 = enabled;
+    this.defaultRoadWidthM_1 = defaultRoadWidthM;
+    this.edgeMarginM_1 = edgeMarginM;
+    this.corridor_1 = corridor;
+    this.cornerEnterRadiusM_1 = cornerEnterRadiusM;
+    this.cornerExitRadiusM_1 = cornerExitRadiusM;
+    this.minCornerLengthM_1 = minCornerLengthM;
+    this.minCornerTurnDeg_1 = minCornerTurnDeg;
+    this.hairpinTurnDeg_1 = hairpinTurnDeg;
+    this.gentleRadiusM_1 = gentleRadiusM;
+    this.regularityFactor_1 = regularityFactor;
+    this.selfProximityGapM_1 = selfProximityGapM;
+    this.straightRunM_1 = straightRunM;
+    this.straightRadiusM_1 = straightRadiusM;
+    this.widthSmoothWindowM_1 = widthSmoothWindowM;
+    this.objectiveRadiusM_1 = objectiveRadiusM;
+    this.steeringLengthM_1 = steeringLengthM;
+    this.centeringLengthM_1 = centeringLengthM;
+    this.maxNewtonIterations_1 = maxNewtonIterations;
+    this.gradientTolerance_1 = gradientTolerance;
+    this.boundEpsilonM_1 = boundEpsilonM;
+    this.curvature_1 = curvature;
+    this.simplifyToleranceCapM_1 = simplifyToleranceCapM;
+    // Inline function 'kotlin.require' call
+    if (!(this.defaultRoadWidthM_1 > 0.0)) {
+      var message = 'defaultRoadWidthM must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.edgeMarginM_1 >= 0.0)) {
+      var message_0 = 'edgeMarginM must be >= 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.cornerEnterRadiusM_1 > 0.0 && this.cornerExitRadiusM_1 > 0.0)) {
+      var message_1 = 'corner radii must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.cornerExitRadiusM_1 >= this.cornerEnterRadiusM_1)) {
+      var message_2 = 'cornerExitRadiusM (' + this.cornerExitRadiusM_1 + ') must be >= cornerEnterRadiusM ' + ('(' + this.cornerEnterRadiusM_1 + '): a corner has to be harder to open than to keep open, or ') + 'the hysteresis runs backwards and corners flicker';
+      throw IllegalArgumentException_init_$Create$(toString(message_2));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.regularityFactor_1 > 0.0 && this.regularityFactor_1 < 1.0)) {
+      var message_3 = 'regularityFactor must be in (0, 1) \u2014 at 1.0 the offset map folds';
+      throw IllegalArgumentException_init_$Create$(toString(message_3));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.selfProximityGapM_1 > 0.0)) {
+      var message_4 = 'selfProximityGapM must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_4));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.widthSmoothWindowM_1 >= 0.0)) {
+      var message_5 = 'widthSmoothWindowM must be >= 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_5));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.objectiveRadiusM_1 > 0.0)) {
+      var message_6 = 'objectiveRadiusM must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_6));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.steeringLengthM_1 > 0.0)) {
+      var message_7 = 'steeringLengthM must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_7));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.centeringLengthM_1 > 0.0)) {
+      var message_8 = 'centeringLengthM must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_8));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.maxNewtonIterations_1 > 0)) {
+      var message_9 = 'maxNewtonIterations must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_9));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.gradientTolerance_1 > 0.0)) {
+      var message_10 = 'gradientTolerance must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_10));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.boundEpsilonM_1 > 0.0)) {
+      var message_11 = 'boundEpsilonM must be > 0';
+      throw IllegalArgumentException_init_$Create$(toString(message_11));
+    }
+  }
+  protoOf(RacingLineOptions).toString = function () {
+    return 'RacingLineOptions(enabled=' + this.enabled_1 + ', defaultRoadWidthM=' + this.defaultRoadWidthM_1 + ', edgeMarginM=' + this.edgeMarginM_1 + ', corridor=' + this.corridor_1.toString() + ', cornerEnterRadiusM=' + this.cornerEnterRadiusM_1 + ', cornerExitRadiusM=' + this.cornerExitRadiusM_1 + ', minCornerLengthM=' + this.minCornerLengthM_1 + ', minCornerTurnDeg=' + this.minCornerTurnDeg_1 + ', hairpinTurnDeg=' + this.hairpinTurnDeg_1 + ', gentleRadiusM=' + this.gentleRadiusM_1 + ', regularityFactor=' + this.regularityFactor_1 + ', selfProximityGapM=' + this.selfProximityGapM_1 + ', straightRunM=' + this.straightRunM_1 + ', straightRadiusM=' + this.straightRadiusM_1 + ', widthSmoothWindowM=' + this.widthSmoothWindowM_1 + ', objectiveRadiusM=' + this.objectiveRadiusM_1 + ', steeringLengthM=' + this.steeringLengthM_1 + ', centeringLengthM=' + this.centeringLengthM_1 + ', maxNewtonIterations=' + this.maxNewtonIterations_1 + ', gradientTolerance=' + this.gradientTolerance_1 + ', boundEpsilonM=' + this.boundEpsilonM_1 + ', curvature=' + this.curvature_1.toString() + ', simplifyToleranceCapM=' + this.simplifyToleranceCapM_1 + ')';
+  };
+  protoOf(RacingLineOptions).hashCode = function () {
+    var result = getBooleanHashCode(this.enabled_1);
+    result = imul(result, 31) + getNumberHashCode(this.defaultRoadWidthM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.edgeMarginM_1) | 0;
+    result = imul(result, 31) + this.corridor_1.hashCode() | 0;
+    result = imul(result, 31) + getNumberHashCode(this.cornerEnterRadiusM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.cornerExitRadiusM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.minCornerLengthM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.minCornerTurnDeg_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.hairpinTurnDeg_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.gentleRadiusM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.regularityFactor_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.selfProximityGapM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.straightRunM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.straightRadiusM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.widthSmoothWindowM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.objectiveRadiusM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.steeringLengthM_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.centeringLengthM_1) | 0;
+    result = imul(result, 31) + this.maxNewtonIterations_1 | 0;
+    result = imul(result, 31) + getNumberHashCode(this.gradientTolerance_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.boundEpsilonM_1) | 0;
+    result = imul(result, 31) + this.curvature_1.hashCode() | 0;
+    result = imul(result, 31) + getNumberHashCode(this.simplifyToleranceCapM_1) | 0;
+    return result;
+  };
+  protoOf(RacingLineOptions).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof RacingLineOptions))
+      return false;
+    if (!(this.enabled_1 === other.enabled_1))
+      return false;
+    if (!equals(this.defaultRoadWidthM_1, other.defaultRoadWidthM_1))
+      return false;
+    if (!equals(this.edgeMarginM_1, other.edgeMarginM_1))
+      return false;
+    if (!this.corridor_1.equals(other.corridor_1))
+      return false;
+    if (!equals(this.cornerEnterRadiusM_1, other.cornerEnterRadiusM_1))
+      return false;
+    if (!equals(this.cornerExitRadiusM_1, other.cornerExitRadiusM_1))
+      return false;
+    if (!equals(this.minCornerLengthM_1, other.minCornerLengthM_1))
+      return false;
+    if (!equals(this.minCornerTurnDeg_1, other.minCornerTurnDeg_1))
+      return false;
+    if (!equals(this.hairpinTurnDeg_1, other.hairpinTurnDeg_1))
+      return false;
+    if (!equals(this.gentleRadiusM_1, other.gentleRadiusM_1))
+      return false;
+    if (!equals(this.regularityFactor_1, other.regularityFactor_1))
+      return false;
+    if (!equals(this.selfProximityGapM_1, other.selfProximityGapM_1))
+      return false;
+    if (!equals(this.straightRunM_1, other.straightRunM_1))
+      return false;
+    if (!equals(this.straightRadiusM_1, other.straightRadiusM_1))
+      return false;
+    if (!equals(this.widthSmoothWindowM_1, other.widthSmoothWindowM_1))
+      return false;
+    if (!equals(this.objectiveRadiusM_1, other.objectiveRadiusM_1))
+      return false;
+    if (!equals(this.steeringLengthM_1, other.steeringLengthM_1))
+      return false;
+    if (!equals(this.centeringLengthM_1, other.centeringLengthM_1))
+      return false;
+    if (!(this.maxNewtonIterations_1 === other.maxNewtonIterations_1))
+      return false;
+    if (!equals(this.gradientTolerance_1, other.gradientTolerance_1))
+      return false;
+    if (!equals(this.boundEpsilonM_1, other.boundEpsilonM_1))
+      return false;
+    if (!this.curvature_1.equals(other.curvature_1))
+      return false;
+    if (!equals(this.simplifyToleranceCapM_1, other.simplifyToleranceCapM_1))
+      return false;
+    return true;
+  };
+  function CorridorMode_LANE_getInstance() {
+    static_init_1();
+    return CorridorMode_LANE_instance;
+  }
+  function CorridorMode_LANE_LEFT_getInstance() {
+    static_init_1();
+    return CorridorMode_LANE_LEFT_instance;
+  }
+  function CorridorMode_FULL_ROAD_getInstance() {
+    static_init_1();
+    return CorridorMode_FULL_ROAD_instance;
+  }
+  function CornerKind_GENTLE_getInstance() {
+    static_init_2();
+    return CornerKind_GENTLE_instance;
+  }
+  function CornerKind_CORNER_getInstance() {
+    static_init_2();
+    return CornerKind_CORNER_instance;
+  }
+  function CornerKind_HAIRPIN_getInstance() {
+    static_init_2();
+    return CornerKind_HAIRPIN_instance;
+  }
+  function get_POWER_PROVIDER_KEYS() {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return POWER_PROVIDER_KEYS;
+  }
+  var POWER_PROVIDER_KEYS;
+  function get_CYCLIST_KEYS() {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return CYCLIST_KEYS;
+  }
+  var CYCLIST_KEYS;
+  function get_BIKE_KEYS() {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return BIKE_KEYS;
+  }
+  var BIKE_KEYS;
+  function get_WIND_KEYS() {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return WIND_KEYS;
+  }
+  var WIND_KEYS;
+  function get_ENHANCE_OPTIONS_KEYS() {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return ENHANCE_OPTIONS_KEYS;
+  }
+  var ENHANCE_OPTIONS_KEYS;
+  function parseGpxWaypoints(xml) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = GpxParser_instance.parse$default_ez0f31_k$(xml).waypoints_1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s = this_0.iterator_jk1svi_k$();
+    while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
+      var item = _iterator__ex2g4s.next_20eer_k$();
+      var tmp$ret$2 = waypointObj(item);
+      destination.add_utx5q5_k$(tmp$ret$2);
+    }
+    // Inline function 'kotlin.collections.toTypedArray' call
+    return copyToArray(destination);
+  }
+  function parseGpx(xml) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return firstTrackAsPath(GpxParser_instance.parse$default_ez0f31_k$(xml));
+  }
+  function parseGpxTracks(xml) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = tracksAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml));
+    return copyToArray(this_0);
+  }
+  function parseGpxSegments(xml) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = segmentsAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml));
+    return copyToArray(this_0);
+  }
+  function parseGpxTracksOnly(xml) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = tracksAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml), setOf(GpxPathKind_TRACK_getInstance()));
+    return copyToArray(this_0);
+  }
+  function parseGpxRoutesOnly(xml) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = tracksAsPaths(GpxParser_instance.parse$default_ez0f31_k$(xml), setOf(GpxPathKind_ROUTE_getInstance()));
+    return copyToArray(this_0);
+  }
+  function writeGpxTracks(paths, waypoints, writeExtensions) {
+    var tmp;
+    if (waypoints === VOID) {
+      // Inline function 'kotlin.emptyArray' call
+      tmp = [];
+    } else {
+      tmp = waypoints;
+    }
+    waypoints = tmp;
+    writeExtensions = writeExtensions === VOID ? true : writeExtensions;
+    _init_properties_EngineJsApi_kt__9bputf();
+    var tmp_0 = GpxWriter_instance;
+    var tmp_1 = toList(paths);
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(waypoints.length);
+    var inductionVariable = 0;
+    var last = waypoints.length;
+    while (inductionVariable < last) {
+      var item = waypoints[inductionVariable];
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp$ret$3 = toGpxWaypoint(item);
+      destination.add_utx5q5_k$(tmp$ret$3);
+    }
+    return tmp_0.write$default_koqy5u_k$(tmp_1, VOID, VOID, destination, VOID, writeExtensions);
+  }
+  function pathSize(path) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return path.size_1;
+  }
+  function pathTotalDistance(path) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return path.totalDistance_1;
+  }
+  function pathDurationMs(path) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return path.durationMs_1;
+  }
+  function pathElevationGain(path) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return path.elevationGain_1;
+  }
+  function pathElevationLoss(path) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return path.elevationLoss_1;
+  }
+  function pointAt(path, i) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return pointObj(path.latitudeDeg_i25sm6_k$(i), path.longitudeDeg_ikk1un_k$(i), path.elevation_iziwkb_k$(i), path.time_ryc845_k$(i), path.speed_npav2n_k$(i), path.pComputedPower_g6dnn4_k$(i), path.distance_5s4s77_k$(i), path.grade_c4yjz5_k$(i));
+  }
+  function writeGpx(path, writeExtensions) {
+    writeExtensions = writeExtensions === VOID ? true : writeExtensions;
+    _init_properties_EngineJsApi_kt__9bputf();
+    return GpxWriter_instance.write_7y52k2_k$(toGpxDocument(path, VOID, 'virtualized'), writeExtensions);
+  }
+  function writeGpxAt(path, startTimeEpochMs, writeExtensions) {
+    writeExtensions = writeExtensions === VOID ? true : writeExtensions;
+    _init_properties_EngineJsApi_kt__9bputf();
+    return GpxWriter_instance.write_7y52k2_k$(toGpxDocument(path, VOID, 'virtualized', Companion_getInstance().fromEpochMilliseconds_uaz65_k$(numberToLong(startTimeEpochMs))), writeExtensions);
+  }
+  function enhance(path, options) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    var tmp = GlobalScope_instance;
+    return promise(tmp, VOID, VOID, enhance$slambda_0(options, path, null));
+  }
+  function enhanceWithCourse(path, cyclist, bike, wind, power, options) {
     _init_properties_EngineJsApi_kt__9bputf();
     var tmp = GlobalScope_instance;
     return promise(tmp, VOID, VOID, enhanceWithCourse$slambda_0(options, path, cyclist, bike, wind, power, null));
@@ -2775,6 +4810,46 @@
     // Inline function 'kotlin.collections.toTypedArray' call
     return copyToArray(destination);
   }
+  function analyzeRacingLine(path, options) {
+    options = options === VOID ? null : options;
+    _init_properties_EngineJsApi_kt__9bputf();
+    var racingLine = toEnhanceOptions(options).racingLine_1;
+    var tmp0_elvis_lhs = RacingLine_instance.analyze_ikwae4_k$(path, racingLine);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return null;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var report = tmp;
+    var o = {};
+    o.size = report.size_1;
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = report.corners_1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s = this_0.iterator_jk1svi_k$();
+    while (_iterator__ex2g4s.hasNext_bitz1p_k$()) {
+      var item = _iterator__ex2g4s.next_20eer_k$();
+      var tmp$ret$2 = cornerObj(item);
+      destination.add_utx5q5_k$(tmp$ret$2);
+    }
+    // Inline function 'kotlin.collections.toTypedArray' call
+    o.corners = copyToArray(destination);
+    o.centerlineCurvature = report.centerlineCurvature_1;
+    o.trajectoryCurvature = report.trajectoryCurvature_1;
+    o.corridorLo = report.corridorLo_1;
+    o.corridorHi = report.corridorHi_1;
+    o.roadHalfWidthM = report.roadHalfWidthM_1;
+    o.lateralOffsetM = report.lateralOffsetM_1;
+    o.maxCorridorWidthM = report.get_maxCorridorWidthM_7bycoc_k$();
+    o.newtonIterations = report.newtonIterations_1;
+    o.relativeGradient = report.relativeGradient_1;
+    o.converged = report.converged_1;
+    o.activeConstraints = report.activeConstraints_1;
+    // Inline function 'kotlin.js.unsafeCast' call
+    return o;
+  }
   function waypointObj(w) {
     _init_properties_EngineJsApi_kt__9bputf();
     var o = {};
@@ -2840,11 +4915,23 @@
     var tmp8_elvis_lhs = _this__u8e3s4.wPrimeBalanceCriticalPower;
     var tmp_7 = tmp8_elvis_lhs == null ? 250.0 : tmp8_elvis_lhs;
     var tmp9_elvis_lhs = _this__u8e3s4.wPrimeBalanceWPrime;
-    return new EnhanceOptions(tmp, tmp_0, tmp_1, tmp_2, tmp_5, new WPrimeBalanceOptions(tmp_6, tmp_7, tmp9_elvis_lhs == null ? 20000.0 : tmp9_elvis_lhs));
+    var tmp_8 = new WPrimeBalanceOptions(tmp_6, tmp_7, tmp9_elvis_lhs == null ? 20000.0 : tmp9_elvis_lhs);
+    var tmp10_elvis_lhs = _this__u8e3s4.curvatureEnabled;
+    var tmp_9 = new CurvatureOptions(tmp10_elvis_lhs == null ? true : tmp10_elvis_lhs);
+    var tmp11_elvis_lhs = _this__u8e3s4.racingLineEnabled;
+    var tmp13_enabled = tmp11_elvis_lhs == null ? false : tmp11_elvis_lhs;
+    var tmp14_corridor = parseCorridor(_this__u8e3s4.racingLineCorridor);
+    var tmp12_elvis_lhs = _this__u8e3s4.racingLineRoadWidthM;
+    var tmp15_defaultRoadWidthM = tmp12_elvis_lhs == null ? Companion_getInstance_17().DEFAULT_1.defaultRoadWidthM_1 : tmp12_elvis_lhs;
+    return new EnhanceOptions(tmp, tmp_0, tmp_1, tmp_2, tmp_5, tmp_8, tmp_9, new RacingLineOptions(tmp13_enabled, tmp15_defaultRoadWidthM, VOID, tmp14_corridor));
+  }
+  function parseCorridor(name) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    return name == null ? Companion_getInstance_17().DEFAULT_1.corridor_1 : Companion_instance_14.byId_8gmd94_k$(name);
   }
   function defaultJsOptions() {
     _init_properties_EngineJsApi_kt__9bputf();
-    return new EnhanceOptions(false, true, true, false, new SimplifyPathOptions(false));
+    return new EnhanceOptions(false, true, true, false, new SimplifyPathOptions(false), VOID, new CurvatureOptions(true), new RacingLineOptions(false));
   }
   function toCyclist(_this__u8e3s4) {
     _init_properties_EngineJsApi_kt__9bputf();
@@ -3021,6 +5108,21 @@
     // Inline function 'kotlin.js.unsafeCast' call
     return o;
   }
+  function cornerObj(c) {
+    _init_properties_EngineJsApi_kt__9bputf();
+    var o = {};
+    o.fromIndex = c.fromIndex_1;
+    o.untilIndex = c.untilIndex_1;
+    o.apexIndex = c.apexIndex_1;
+    o.kind = c.kind_1.name_1;
+    o.turnRad = c.turnRad_1;
+    o.direction = c.direction_1;
+    o.radiusQ20M = c.radiusQ20M_1;
+    o.radiusMinM = c.radiusMinM_1;
+    o.lengthM = c.lengthM_1;
+    // Inline function 'kotlin.js.unsafeCast' call
+    return o;
+  }
   function enhance$slambda($options, $path, resultContinuation) {
     this.$options_1 = $options;
     this.$path_1 = $path;
@@ -3150,7 +5252,7 @@
       CYCLIST_KEYS = setOf_0(['massKg', 'cd', 'frontalAreaM2', 'maxLeanAngleDeg', 'maxBrakeG', 'maxSpeedKmH', 'roadCondition']);
       BIKE_KEYS = setOf_0(['crr', 'inertiaFront', 'inertiaRear', 'wheelRadiusM', 'efficiency', 'maxPedalingLeanAngleDeg']);
       WIND_KEYS = setOf_0(['windSpeed', 'windDirection']);
-      ENHANCE_OPTIONS_KEYS = setOf_0(['fixElevation', 'computeMaxSpeeds', 'virtualizeTrack', 'computeOnePointPerSecond', 'simplifyEnabled', 'simplifyToleranceM', 'simplifyZExaggeration', 'wPrimeBalanceEnabled', 'wPrimeBalanceCriticalPower', 'wPrimeBalanceWPrime']);
+      ENHANCE_OPTIONS_KEYS = setOf_0(['fixElevation', 'computeMaxSpeeds', 'virtualizeTrack', 'computeOnePointPerSecond', 'simplifyEnabled', 'simplifyToleranceM', 'simplifyZExaggeration', 'wPrimeBalanceEnabled', 'wPrimeBalanceCriticalPower', 'wPrimeBalanceWPrime', 'curvatureEnabled', 'racingLineEnabled', 'racingLineCorridor', 'racingLineRoadWidthM']);
     }
   }
   //region block: init
@@ -3176,6 +5278,16 @@
   WheelBearingsPowerProvider_instance = new WheelBearingsPowerProvider();
   WindProviderNone_instance = new WindProviderNone();
   WPrimeBalanceComputer_instance = new WPrimeBalanceComputer();
+  BandedLdl_instance = new BandedLdl();
+  CornerDetector_instance = new CornerDetector();
+  Corridor_instance = new Corridor();
+  CurvatureEstimator_instance = new CurvatureEstimator();
+  LocalFrame_instance = new LocalFrame();
+  Companion_instance_12 = new Companion_11();
+  OffsetQp_instance = new OffsetQp();
+  PathCurvature_instance = new PathCurvature();
+  RacingLine_instance = new RacingLine();
+  Companion_instance_14 = new Companion_13();
   //endregion
   //region block: exports
   function $jsExportAll$(_) {
@@ -3212,6 +5324,7 @@
     engine.dominantHeadwindAzimuthOfTracks = dominantHeadwindAzimuthOfTracks;
     engine.detectClimbs = detectClimbs;
     engine.detectClimbsWithOptions = detectClimbsWithOptions;
+    engine.analyzeRacingLine = analyzeRacingLine;
   }
   $jsExportAll$(_);
   kotlin_io_github_glandais_elevation.$jsExportAll$(_);