@glandais/vcyclist-engine 0.0.0

package/vcyclist-elevation.js

@@ -0,0 +1,2373 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './kotlinx-coroutines-core.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./kotlinx-coroutines-core.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'vcyclist-elevation'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'vcyclist-elevation'.");
+    }
+    if (typeof globalThis['kotlinx-coroutines-core'] === 'undefined') {
+      throw new Error("Error loading module 'vcyclist-elevation'. Its dependency 'kotlinx-coroutines-core' was not found. Please, check whether 'kotlinx-coroutines-core' is loaded prior to 'vcyclist-elevation'.");
+    }
+    globalThis['vcyclist-elevation'] = factory(typeof globalThis['vcyclist-elevation'] === 'undefined' ? {} : globalThis['vcyclist-elevation'], globalThis['kotlin-kotlin-stdlib'], globalThis['kotlinx-coroutines-core']);
+  }
+}(function (_, kotlin_kotlin, kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var hypot = Math.hypot;
+  var VOID = kotlin_kotlin.$_$.a;
+  var protoOf = kotlin_kotlin.$_$.e5;
+  var getNumberHashCode = kotlin_kotlin.$_$.o4;
+  var getBooleanHashCode = kotlin_kotlin.$_$.n4;
+  var equals = kotlin_kotlin.$_$.m4;
+  var initMetadataForClass = kotlin_kotlin.$_$.s4;
+  var numberToLong = kotlin_kotlin.$_$.a4;
+  var toNumber = kotlin_kotlin.$_$.c4;
+  var CoroutineImpl = kotlin_kotlin.$_$.m3;
+  var Unit_instance = kotlin_kotlin.$_$.g;
+  var THROW_CCE = kotlin_kotlin.$_$.o6;
+  var MutableEntry = kotlin_kotlin.$_$.z1;
+  var isInterface = kotlin_kotlin.$_$.a5;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.x2;
+  var initMetadataForLambda = kotlin_kotlin.$_$.x4;
+  var emptyList = kotlin_kotlin.$_$.j2;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.n;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.j;
+  var toList = kotlin_kotlin.$_$.v2;
+  var KtList = kotlin_kotlin.$_$.x1;
+  var initMetadataForCoroutine = kotlin_kotlin.$_$.u4;
+  var toString = kotlin_kotlin.$_$.g5;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.y;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.i;
+  var listOf = kotlin_kotlin.$_$.q2;
+  var numberToInt = kotlin_kotlin.$_$.c5;
+  var initMetadataForObject = kotlin_kotlin.$_$.y4;
+  var toList_0 = kotlin_kotlin.$_$.u2;
+  var get_lastIndex = kotlin_kotlin.$_$.o2;
+  var checkBuilderCapacity = kotlin_kotlin.$_$.b2;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var coerceIn = kotlin_kotlin.$_$.m5;
+  var initMetadataForFunctionReference = kotlin_kotlin.$_$.v4;
+  var getStringHashCode = kotlin_kotlin.$_$.q4;
+  var CoroutineScope = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.h;
+  var Semaphore = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.f;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.c2;
+  var async = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.i;
+  var awaitAll = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.b;
+  var coroutineScope = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.d;
+  var CompletableDeferred = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.g;
+  var KtMap = kotlin_kotlin.$_$.y1;
+  var Mutex = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.e;
+  var contentEquals = kotlin_kotlin.$_$.d2;
+  var contentHashCode = kotlin_kotlin.$_$.e2;
+  var objectCreate = kotlin_kotlin.$_$.d5;
+  var round = kotlin_kotlin.$_$.i5;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.t4;
+  var isNaN_0 = kotlin_kotlin.$_$.u6;
+  var replace = kotlin_kotlin.$_$.w5;
+  var coerceIn_0 = kotlin_kotlin.$_$.l5;
+  var GlobalScope_instance = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.a;
+  var promise = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.j;
+  var await_0 = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.c;
+  var IllegalStateException_init_$Create$_0 = kotlin_kotlin.$_$.a1;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForClass(SmoothingOptions, 'SmoothingOptions', SmoothingOptions);
+  initMetadataForClass(FilterOptions, 'FilterOptions', FilterOptions);
+  initMetadataForLambda(BatchCalculator$setElevations$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForCoroutine($setElevationsCOROUTINE$, CoroutineImpl);
+  initMetadataForCoroutine($getElevationsAlongCOROUTINE$, CoroutineImpl);
+  initMetadataForClass(BatchCalculator, 'BatchCalculator', VOID, VOID, VOID, [4, 7]);
+  initMetadataForObject(MathConstants, 'MathConstants');
+  initMetadataForClass(LatLon, 'LatLon');
+  initMetadataForClass(LatLonElevation, 'LatLonElevation');
+  initMetadataForObject(Distance, 'Distance');
+  initMetadataForObject(DouglasPeucker, 'DouglasPeucker');
+  initMetadataForObject(EcefConverter, 'EcefConverter');
+  initMetadataForCoroutine($getElevationCOROUTINE$, CoroutineImpl);
+  initMetadataForCoroutine($getInterpolatedElevationCOROUTINE$, CoroutineImpl);
+  initMetadataForCoroutine($elevationFromPixelCOROUTINE$, CoroutineImpl);
+  initMetadataForClass(ElevationCalculator, 'ElevationCalculator', VOID, VOID, VOID, [3, 2, 1]);
+  initMetadataForObject(ElevationFunctions, 'ElevationFunctions');
+  initMetadataForFunctionReference(fetchAndDecodeTile$ref, VOID, VOID, [1]);
+  initMetadataForClass(ElevationProvider, 'ElevationProvider', ElevationProvider, VOID, VOID, [3, 2, 6]);
+  initMetadataForClass(ElevationProviderConfig, 'ElevationProviderConfig', ElevationProviderConfig);
+  initMetadataForClass(Attribution, 'Attribution');
+  initMetadataForObject(ElevationSmoother, 'ElevationSmoother');
+  initMetadataForLambda(Flux$forEachParallel$slambda$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForLambda(Flux$forEachParallel$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForCoroutine($forEachParallelCOROUTINE$, CoroutineImpl);
+  initMetadataForObject(Flux, 'Flux', VOID, VOID, VOID, [3]);
+  initMetadataForCoroutine($getCOROUTINE$, CoroutineImpl);
+  initMetadataForClass(LruCache, 'LruCache', VOID, VOID, VOID, [1, 0]);
+  initMetadataForClass(RawTile, 'RawTile');
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(Tile, 'Tile');
+  initMetadataForFunctionReference(fetchAndDecodeTile$ref_1, VOID, VOID, [1]);
+  initMetadataForLambda(TileManager$cache$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForClass(TileManager, 'TileManager', VOID, VOID, VOID, [1, 0]);
+  initMetadataForClass(TileCoordinates, 'TileCoordinates');
+  initMetadataForClass(Pixel, 'Pixel');
+  initMetadataForClass(PixelFloat, 'PixelFloat');
+  initMetadataForClass(TileCoordinatesFloat, 'TileCoordinatesFloat');
+  initMetadataForCompanion(Companion_0);
+  initMetadataForClass(Vector3D, 'Vector3D');
+  initMetadataForLambda(getElevation$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForLambda(getElevationsAlong$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForCoroutine($fetchAndDecodeTileCOROUTINE$, CoroutineImpl);
+  //endregion
+  function SmoothingOptions(windowSize, enabled) {
+    windowSize = windowSize === VOID ? 50.0 : windowSize;
+    enabled = enabled === VOID ? false : enabled;
+    this.fs_1 = windowSize;
+    this.gs_1 = enabled;
+  }
+  protoOf(SmoothingOptions).toString = function () {
+    return 'SmoothingOptions(windowSize=' + this.fs_1 + ', enabled=' + this.gs_1 + ')';
+  };
+  protoOf(SmoothingOptions).hashCode = function () {
+    var result = this.fs_1 == null ? 0 : getNumberHashCode(this.fs_1);
+    result = imul(result, 31) + getBooleanHashCode(this.gs_1) | 0;
+    return result;
+  };
+  protoOf(SmoothingOptions).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof SmoothingOptions))
+      return false;
+    if (!equals(this.fs_1, other.fs_1))
+      return false;
+    if (!(this.gs_1 === other.gs_1))
+      return false;
+    return true;
+  };
+  function FilterOptions(tolerance, zExaggeration, enabled) {
+    tolerance = tolerance === VOID ? 10.0 : tolerance;
+    zExaggeration = zExaggeration === VOID ? 3.0 : zExaggeration;
+    enabled = enabled === VOID ? false : enabled;
+    this.hs_1 = tolerance;
+    this.is_1 = zExaggeration;
+    this.js_1 = enabled;
+  }
+  protoOf(FilterOptions).toString = function () {
+    return 'FilterOptions(tolerance=' + this.hs_1 + ', zExaggeration=' + this.is_1 + ', enabled=' + this.js_1 + ')';
+  };
+  protoOf(FilterOptions).hashCode = function () {
+    var result = this.hs_1 == null ? 0 : getNumberHashCode(this.hs_1);
+    result = imul(result, 31) + (this.is_1 == null ? 0 : getNumberHashCode(this.is_1)) | 0;
+    result = imul(result, 31) + getBooleanHashCode(this.js_1) | 0;
+    return result;
+  };
+  protoOf(FilterOptions).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof FilterOptions))
+      return false;
+    if (!equals(this.hs_1, other.hs_1))
+      return false;
+    if (!equals(this.is_1, other.is_1))
+      return false;
+    if (!(this.js_1 === other.js_1))
+      return false;
+    return true;
+  };
+  function formatNumber($this, d) {
+    var asLong = numberToLong(d);
+    return toNumber(asLong) === d ? asLong.toString() : d.toString();
+  }
+  function BatchCalculator$setElevations$slambda($coordinates, this$0, $zoomLevel, $interpolation, $results, resultContinuation) {
+    this.ss_1 = $coordinates;
+    this.ts_1 = this$0;
+    this.us_1 = $zoomLevel;
+    this.vs_1 = $interpolation;
+    this.ws_1 = $results;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(BatchCalculator$setElevations$slambda).bt = function (_destruct__k2r9zo, $completion) {
+    var tmp = this.ct(_destruct__k2r9zo, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(BatchCalculator$setElevations$slambda).k6 = function (p1, $completion) {
+    return this.bt((!(p1 == null) ? isInterface(p1, MutableEntry) : false) ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(BatchCalculator$setElevations$slambda).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 4;
+            var indices = this.xs_1.f1();
+            this.at_1 = indices.i();
+            this.u5_1 = 1;
+            continue $sm;
+          case 1:
+            if (!this.at_1.j()) {
+              this.u5_1 = 3;
+              continue $sm;
+            }
+
+            this.zs_1 = this.at_1.k();
+            this.ys_1 = this.ss_1.m(this.zs_1);
+            this.u5_1 = 2;
+            suspendResult = this.ts_1.dt_1.gt(this.ys_1, this.us_1, this.vs_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            var ele = suspendResult;
+            this.ws_1[this.zs_1] = new LatLonElevation(this.ys_1.ht(), this.ys_1.it(), ele);
+            this.u5_1 = 1;
+            continue $sm;
+          case 3:
+            return Unit_instance;
+          case 4:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 4) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(BatchCalculator$setElevations$slambda).ct = function (_destruct__k2r9zo, completion) {
+    var i = new BatchCalculator$setElevations$slambda(this.ss_1, this.ts_1, this.us_1, this.vs_1, this.ws_1, completion);
+    i.xs_1 = _destruct__k2r9zo;
+    return i;
+  };
+  function BatchCalculator$setElevations$slambda_0($coordinates, this$0, $zoomLevel, $interpolation, $results, resultContinuation) {
+    var i = new BatchCalculator$setElevations$slambda($coordinates, this$0, $zoomLevel, $interpolation, $results, resultContinuation);
+    var l = function (_destruct__k2r9zo, $completion) {
+      return i.bt(_destruct__k2r9zo, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function $setElevationsCOROUTINE$(_this__u8e3s4, coordinates, zoomLevel, interpolation, maxParallelTiles, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.rt_1 = _this__u8e3s4;
+    this.st_1 = coordinates;
+    this.tt_1 = zoomLevel;
+    this.ut_1 = interpolation;
+    this.vt_1 = maxParallelTiles;
+  }
+  protoOf($setElevationsCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            if (this.st_1.n())
+              return emptyList();
+            var tmp_0 = this;
+            var size = this.st_1.l();
+            tmp_0.wt_1 = Array(size);
+            var byTile = LinkedHashMap_init_$Create$();
+            var iterator = this.st_1.i();
+            var index = 0;
+            while (iterator.j()) {
+              var i = index;
+              index = index + 1 | 0;
+              var p = iterator.k();
+              var tile = ElevationFunctions_instance.xt(p, this.tt_1);
+              var key = '' + tile.au_1 + '/' + tile.yt_1 + '/' + tile.zt_1;
+              var value = byTile.h1(key);
+              var tmp_1;
+              if (value == null) {
+                var answer = ArrayList_init_$Create$();
+                byTile.p2(key, answer);
+                tmp_1 = answer;
+              } else {
+                tmp_1 = value;
+              }
+              tmp_1.h(i);
+            }
+
+            this.u5_1 = 1;
+            var tmp_2 = Flux_instance;
+            var tmp_3 = byTile.j1();
+            suspendResult = tmp_2.bu(tmp_3, this.vt_1, BatchCalculator$setElevations$slambda_0(this.st_1, this.rt_1, this.tt_1, this.ut_1, this.wt_1, null), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            var tmp_4 = toList(this.wt_1);
+            return isInterface(tmp_4, KtList) ? tmp_4 : THROW_CCE();
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function $getElevationsAlongCOROUTINE$(_this__u8e3s4, path, zoomLevel, step, minDistance, interpolation, smoothingOptions, filterOptions, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.ku_1 = _this__u8e3s4;
+    this.lu_1 = path;
+    this.mu_1 = zoomLevel;
+    this.nu_1 = step;
+    this.ou_1 = minDistance;
+    this.pu_1 = interpolation;
+    this.qu_1 = smoothingOptions;
+    this.ru_1 = filterOptions;
+  }
+  protoOf($getElevationsAlongCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            if (!(this.lu_1.l() >= 2)) {
+              var message = 'Path must contain at least 2 coordinates';
+              throw IllegalArgumentException_init_$Create$(toString(message));
+            }
+
+            if (!(this.nu_1 > 1.0)) {
+              var message_0 = 'Step is too small: ' + formatNumber(this.ku_1, this.nu_1) + ' meters';
+              throw IllegalArgumentException_init_$Create$(toString(message_0));
+            }
+
+            var densified = this.ku_1.su(this.lu_1, this.nu_1, this.ou_1);
+            this.u5_1 = 1;
+            suspendResult = this.ku_1.tu(densified, this.mu_1, this.pu_1, VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            var withElevation = suspendResult;
+            var tmp_0;
+            var tmp1_safe_receiver = this.qu_1;
+            if ((tmp1_safe_receiver == null ? null : tmp1_safe_receiver.gs_1) === true) {
+              tmp_0 = withElevation.l() >= 3;
+            } else {
+              tmp_0 = false;
+            }
+
+            if (tmp_0) {
+              var tmp_1 = ElevationSmoother_instance;
+              var tmp_2 = withElevation;
+              var tmp0_elvis_lhs = this.qu_1.fs_1;
+              withElevation = tmp_1.uu(tmp_2, tmp0_elvis_lhs == null ? 50.0 : tmp0_elvis_lhs);
+            }
+
+            var tmp_3;
+            var tmp4_safe_receiver = this.ru_1;
+            if ((tmp4_safe_receiver == null ? null : tmp4_safe_receiver.js_1) === true) {
+              tmp_3 = withElevation.l() > 2;
+            } else {
+              tmp_3 = false;
+            }
+
+            if (tmp_3) {
+              var tmp_4 = DouglasPeucker_instance;
+              var tmp_5 = withElevation;
+              var tmp2_elvis_lhs = this.ru_1.hs_1;
+              var tmp_6 = tmp2_elvis_lhs == null ? 10.0 : tmp2_elvis_lhs;
+              var tmp3_elvis_lhs = this.ru_1.is_1;
+              withElevation = tmp_4.vu(tmp_5, tmp_6, tmp3_elvis_lhs == null ? 3.0 : tmp3_elvis_lhs);
+            }
+
+            return withElevation;
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function BatchCalculator(calculator) {
+    this.dt_1 = calculator;
+  }
+  protoOf(BatchCalculator).wu = function (coordinates, zoomLevel, interpolation, maxParallelTiles, $completion) {
+    var tmp = new $setElevationsCOROUTINE$(this, coordinates, zoomLevel, interpolation, maxParallelTiles, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(BatchCalculator).tu = function (coordinates, zoomLevel, interpolation, maxParallelTiles, $completion, $super) {
+    maxParallelTiles = maxParallelTiles === VOID ? 10 : maxParallelTiles;
+    return $super === VOID ? this.wu(coordinates, zoomLevel, interpolation, maxParallelTiles, $completion) : $super.wu.call(this, coordinates, zoomLevel, interpolation, maxParallelTiles, $completion);
+  };
+  protoOf(BatchCalculator).xu = function (path, zoomLevel, step, minDistance, interpolation, smoothingOptions, filterOptions, $completion) {
+    var tmp = new $getElevationsAlongCOROUTINE$(this, path, zoomLevel, step, minDistance, interpolation, smoothingOptions, filterOptions, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(BatchCalculator).su = function (path, step, minDistance) {
+    if (path.n())
+      return emptyList();
+    var out = ArrayList_init_$Create$_0(imul(path.l(), 2));
+    // Inline function 'kotlin.collections.plusAssign' call
+    var element = path.m(0);
+    out.h(element);
+    var inductionVariable = 0;
+    var last = path.l() - 1 | 0;
+    if (inductionVariable < last)
+      $l$loop: do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var a = path.m(i);
+        var b = path.m(i + 1 | 0);
+        var d = Distance_instance.yu(a, b);
+        if (d < minDistance)
+          continue $l$loop;
+        var between = this.zu(a, b, step, d);
+        var inductionVariable_0 = 1;
+        var last_0 = between.l();
+        if (inductionVariable_0 < last_0)
+          do {
+            var j = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            // Inline function 'kotlin.collections.plusAssign' call
+            var element_0 = between.m(j);
+            out.h(element_0);
+          }
+           while (inductionVariable_0 < last_0);
+      }
+       while (inductionVariable < last);
+    return out;
+  };
+  protoOf(BatchCalculator).zu = function (a, b, step, distance) {
+    if (distance <= step)
+      return listOf([a, b]);
+    var numSteps = numberToInt(distance / step);
+    var out = ArrayList_init_$Create$_0(numSteps + 2 | 0);
+    // Inline function 'kotlin.collections.plusAssign' call
+    out.h(a);
+    var latDiff = b.ht() - a.ht();
+    var lonDiff = b.it() - a.it();
+    var inductionVariable = 1;
+    if (inductionVariable <= numSteps)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var f = i * step / distance;
+        // Inline function 'kotlin.collections.plusAssign' call
+        var element = new LatLon(a.ht() + latDiff * f, a.it() + lonDiff * f);
+        out.h(element);
+      }
+       while (!(i === numSteps));
+    // Inline function 'kotlin.collections.plusAssign' call
+    out.h(b);
+    return out;
+  };
+  function MathConstants() {
+    MathConstants_instance = this;
+    this.av_1 = 3.141592653589793 / 180.0;
+    this.bv_1 = 180.0 / 3.141592653589793;
+  }
+  var MathConstants_instance;
+  function MathConstants_getInstance() {
+    if (MathConstants_instance == null)
+      new MathConstants();
+    return MathConstants_instance;
+  }
+  function LatLon(latitude, longitude, elevation) {
+    elevation = elevation === VOID ? null : elevation;
+    this.cv_1 = latitude;
+    this.dv_1 = longitude;
+    this.ev_1 = elevation;
+  }
+  protoOf(LatLon).ht = function () {
+    return this.cv_1;
+  };
+  protoOf(LatLon).it = function () {
+    return this.dv_1;
+  };
+  protoOf(LatLon).fv = function () {
+    return this.ev_1;
+  };
+  protoOf(LatLon).toString = function () {
+    return 'LatLon(latitude=' + this.cv_1 + ', longitude=' + this.dv_1 + ', elevation=' + this.ev_1 + ')';
+  };
+  protoOf(LatLon).hashCode = function () {
+    var result = getNumberHashCode(this.cv_1);
+    result = imul(result, 31) + getNumberHashCode(this.dv_1) | 0;
+    result = imul(result, 31) + (this.ev_1 == null ? 0 : getNumberHashCode(this.ev_1)) | 0;
+    return result;
+  };
+  protoOf(LatLon).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof LatLon))
+      return false;
+    if (!equals(this.cv_1, other.cv_1))
+      return false;
+    if (!equals(this.dv_1, other.dv_1))
+      return false;
+    if (!equals(this.ev_1, other.ev_1))
+      return false;
+    return true;
+  };
+  function LatLonElevation(latitude, longitude, elevation) {
+    this.gv_1 = latitude;
+    this.hv_1 = longitude;
+    this.iv_1 = elevation;
+  }
+  protoOf(LatLonElevation).ht = function () {
+    return this.gv_1;
+  };
+  protoOf(LatLonElevation).it = function () {
+    return this.hv_1;
+  };
+  protoOf(LatLonElevation).fv = function () {
+    return this.iv_1;
+  };
+  protoOf(LatLonElevation).toString = function () {
+    return 'LatLonElevation(latitude=' + this.gv_1 + ', longitude=' + this.hv_1 + ', elevation=' + this.iv_1 + ')';
+  };
+  protoOf(LatLonElevation).hashCode = function () {
+    var result = getNumberHashCode(this.gv_1);
+    result = imul(result, 31) + getNumberHashCode(this.hv_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.iv_1) | 0;
+    return result;
+  };
+  protoOf(LatLonElevation).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof LatLonElevation))
+      return false;
+    if (!equals(this.gv_1, other.gv_1))
+      return false;
+    if (!equals(this.hv_1, other.hv_1))
+      return false;
+    if (!equals(this.iv_1, other.iv_1))
+      return false;
+    return true;
+  };
+  function Distance() {
+  }
+  protoOf(Distance).yu = function (coord1, coord2) {
+    var lat1Rad = coord1.ht() * MathConstants_getInstance().av_1;
+    var lat2Rad = coord2.ht() * MathConstants_getInstance().av_1;
+    var deltaLat = (coord2.ht() - coord1.ht()) * MathConstants_getInstance().av_1;
+    var deltaLon = (coord2.it() - coord1.it()) * MathConstants_getInstance().av_1;
+    // Inline function 'kotlin.math.sin' call
+    var x = deltaLat / 2.0;
+    var sinHalfLat = Math.sin(x);
+    // Inline function 'kotlin.math.sin' call
+    var x_0 = deltaLon / 2.0;
+    var sinHalfLon = Math.sin(x_0);
+    var tmp = sinHalfLat * sinHalfLat;
+    // Inline function 'kotlin.math.cos' call
+    var tmp_0 = Math.cos(lat1Rad);
+    // Inline function 'kotlin.math.cos' call
+    var a = tmp + tmp_0 * Math.cos(lat2Rad) * sinHalfLon * sinHalfLon;
+    // Inline function 'kotlin.math.sqrt' call
+    var tmp0 = Math.sqrt(a);
+    // Inline function 'kotlin.math.sqrt' call
+    var x_1 = 1.0 - a;
+    // Inline function 'kotlin.math.atan2' call
+    var x_2 = Math.sqrt(x_1);
+    var c = 2.0 * Math.atan2(tmp0, x_2);
+    return 6371000.0 * c;
+  };
+  protoOf(Distance).jv = function (points) {
+    if (points.n()) {
+      // Inline function 'kotlin.doubleArrayOf' call
+      return new Float64Array([0.0]);
+    }
+    var out = new Float64Array(points.l());
+    var inductionVariable = 1;
+    var last = points.l();
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        out[i] = out[i - 1 | 0] + this.yu(points.m(i - 1 | 0), points.m(i));
+      }
+       while (inductionVariable < last);
+    return out;
+  };
+  var Distance_instance;
+  function Distance_getInstance() {
+    return Distance_instance;
+  }
+  function simplifyRecursive($this, points, firstIndex, lastIndex, tolerance, zExaggeration, out) {
+    var firstEcef = EcefConverter_instance.kv(points.m(firstIndex), zExaggeration);
+    var lastEcef = EcefConverter_instance.kv(points.m(lastIndex), zExaggeration);
+    var maxDistance = 0.0;
+    var maxIndex = -1;
+    var inductionVariable = firstIndex + 1 | 0;
+    if (inductionVariable < lastIndex)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var d = EcefConverter_instance.kv(points.m(i), zExaggeration).ov(firstEcef, lastEcef);
+        if (d > maxDistance) {
+          maxDistance = d;
+          maxIndex = i;
+        }
+      }
+       while (inductionVariable < lastIndex);
+    if (maxDistance > tolerance && !(maxIndex === -1)) {
+      if ((maxIndex - firstIndex | 0) > 1) {
+        simplifyRecursive($this, points, firstIndex, maxIndex, tolerance, zExaggeration, out);
+      }
+      out.h(points.m(maxIndex));
+      if ((lastIndex - maxIndex | 0) > 1) {
+        simplifyRecursive($this, points, maxIndex, lastIndex, tolerance, zExaggeration, out);
+      }
+    }
+  }
+  function DouglasPeucker() {
+  }
+  protoOf(DouglasPeucker).vu = function (points, tolerance, zExaggeration) {
+    if (points.l() <= 2)
+      return toList_0(points);
+    var lastIndex = get_lastIndex(points);
+    // Inline function 'kotlin.collections.buildList' call
+    // Inline function 'kotlin.collections.buildListInternal' call
+    var capacity = points.l();
+    checkBuilderCapacity(capacity);
+    // Inline function 'kotlin.apply' call
+    var this_0 = ArrayList_init_$Create$_0(capacity);
+    this_0.h(points.m(0));
+    simplifyRecursive(DouglasPeucker_instance, points, 0, lastIndex, tolerance, zExaggeration, this_0);
+    this_0.h(points.m(lastIndex));
+    return this_0.c3();
+  };
+  var DouglasPeucker_instance;
+  function DouglasPeucker_getInstance() {
+    return DouglasPeucker_instance;
+  }
+  function EcefConverter() {
+  }
+  protoOf(EcefConverter).kv = function (coordinates, zExaggeration) {
+    var latRad = coordinates.ht() * MathConstants_getInstance().av_1;
+    var lonRad = coordinates.it() * MathConstants_getInstance().av_1;
+    var tmp0_elvis_lhs = coordinates.fv();
+    var elevationExaggerated = zExaggeration * (tmp0_elvis_lhs == null ? 0.0 : tmp0_elvis_lhs);
+    // Inline function 'kotlin.math.sin' call
+    var sinLat = Math.sin(latRad);
+    // Inline function 'kotlin.math.sqrt' call
+    var x = 1.0 - 0.00669437999014 * sinLat * sinLat;
+    var n = 6378137.0 / Math.sqrt(x);
+    // Inline function 'kotlin.math.cos' call
+    var cosLat = Math.cos(latRad);
+    // Inline function 'kotlin.math.cos' call
+    var cosLon = Math.cos(lonRad);
+    // Inline function 'kotlin.math.sin' call
+    var sinLon = Math.sin(lonRad);
+    var x_0 = (n + elevationExaggerated) * cosLat * cosLon;
+    var y = (n + elevationExaggerated) * cosLat * sinLon;
+    var z = (n * (1.0 - 0.00669437999014) + elevationExaggerated) * sinLat;
+    return new Vector3D(x_0, y, z);
+  };
+  var EcefConverter_instance;
+  function EcefConverter_getInstance() {
+    return EcefConverter_instance;
+  }
+  function getInterpolatedElevation($this, coords, zoomLevel, $completion) {
+    var tmp = new $getInterpolatedElevationCOROUTINE$($this, coords, zoomLevel, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  }
+  function elevationFromPixel($this, pixel, $completion) {
+    var tmp = new $elevationFromPixelCOROUTINE$($this, pixel, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  }
+  function $getElevationCOROUTINE$(_this__u8e3s4, coords, zoomLevel, interpolation, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.cx_1 = _this__u8e3s4;
+    this.dx_1 = coords;
+    this.ex_1 = zoomLevel;
+    this.fx_1 = interpolation;
+  }
+  protoOf($getElevationCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 5;
+            this.v5_1 = 4;
+            if (this.fx_1) {
+              this.u5_1 = 2;
+              suspendResult = getInterpolatedElevation(this.cx_1, this.dx_1, this.ex_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              var pixel = ElevationFunctions_instance.ix(this.dx_1, this.ex_1, this.cx_1.ft_1);
+              this.u5_1 = 1;
+              suspendResult = elevationFromPixel(this.cx_1, pixel, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            }
+
+          case 1:
+            this.hx_1 = suspendResult;
+            this.u5_1 = 3;
+            continue $sm;
+          case 2:
+            this.hx_1 = suspendResult;
+            this.u5_1 = 3;
+            continue $sm;
+          case 3:
+            this.gx_1 = this.hx_1;
+            this.v5_1 = 5;
+            this.u5_1 = 6;
+            continue $sm;
+          case 4:
+            this.v5_1 = 5;
+            var tmp_0 = this.x5_1;
+            if (tmp_0 instanceof Error) {
+              var t = this.x5_1;
+              var tmp_1 = this;
+              throw IllegalStateException_init_$Create$('Failed to get elevation: ' + t.message, t);
+            } else {
+              throw this.x5_1;
+            }
+
+          case 5:
+            throw this.x5_1;
+          case 6:
+            this.v5_1 = 5;
+            return this.gx_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 5) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function $getInterpolatedElevationCOROUTINE$(_this__u8e3s4, coords, zoomLevel, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.xv_1 = _this__u8e3s4;
+    this.yv_1 = coords;
+    this.zv_1 = zoomLevel;
+  }
+  protoOf($getInterpolatedElevationCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 5;
+            this.hw_1 = ElevationFunctions_instance.jx(this.yv_1, this.zv_1, this.xv_1.ft_1);
+            var tmp_0 = this;
+            var x = this.hw_1.lx_1;
+            tmp_0.iw_1 = numberToInt(Math.floor(x));
+            var tmp_1 = this;
+            var x_0 = this.hw_1.mx_1;
+            tmp_1.jw_1 = numberToInt(Math.floor(x_0));
+            this.gw_1 = this.iw_1 + 1 | 0;
+            this.fw_1 = this.jw_1 + 1 | 0;
+            this.bw_1 = this.hw_1.lx_1 - this.iw_1;
+            this.aw_1 = this.hw_1.mx_1 - this.jw_1;
+            this.u5_1 = 1;
+            suspendResult = elevationFromPixel(this.xv_1, ElevationFunctions_instance.nx(new Pixel(this.hw_1.kx_1, this.iw_1, this.jw_1), this.xv_1.ft_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            this.ew_1 = suspendResult;
+            this.u5_1 = 2;
+            suspendResult = elevationFromPixel(this.xv_1, ElevationFunctions_instance.nx(new Pixel(this.hw_1.kx_1, this.gw_1, this.jw_1), this.xv_1.ft_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            this.dw_1 = suspendResult;
+            this.u5_1 = 3;
+            suspendResult = elevationFromPixel(this.xv_1, ElevationFunctions_instance.nx(new Pixel(this.hw_1.kx_1, this.iw_1, this.fw_1), this.xv_1.ft_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 3:
+            this.cw_1 = suspendResult;
+            this.u5_1 = 4;
+            suspendResult = elevationFromPixel(this.xv_1, ElevationFunctions_instance.nx(new Pixel(this.hw_1.kx_1, this.gw_1, this.fw_1), this.xv_1.ft_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 4:
+            var p11 = suspendResult;
+            var top = this.ew_1 * (1.0 - this.bw_1) + this.dw_1 * this.bw_1;
+            var bottom = this.cw_1 * (1.0 - this.bw_1) + p11 * this.bw_1;
+            return top * (1.0 - this.aw_1) + bottom * this.aw_1;
+          case 5:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 5) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function $elevationFromPixelCOROUTINE$(_this__u8e3s4, pixel, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.sw_1 = _this__u8e3s4;
+    this.tw_1 = pixel;
+  }
+  protoOf($elevationFromPixelCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            this.u5_1 = 1;
+            suspendResult = this.sw_1.et_1.ux(this.tw_1.ox_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            return suspendResult.ay(this.tw_1);
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function ElevationCalculator(tileManager, tileSize) {
+    tileSize = tileSize === VOID ? 256 : tileSize;
+    this.et_1 = tileManager;
+    this.ft_1 = tileSize;
+  }
+  protoOf(ElevationCalculator).gt = function (coords, zoomLevel, interpolation, $completion) {
+    var tmp = new $getElevationCOROUTINE$(this, coords, zoomLevel, interpolation, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  function formatNumber_0($this, d) {
+    var asLong = numberToLong(d);
+    return toNumber(asLong) === d ? asLong.toString() : d.toString();
+  }
+  function ElevationFunctions() {
+  }
+  protoOf(ElevationFunctions).by = function (degrees) {
+    return degrees * MathConstants_getInstance().av_1;
+  };
+  protoOf(ElevationFunctions).cy = function (lat) {
+    return lat >= -85.0511 && lat <= 85.0511;
+  };
+  protoOf(ElevationFunctions).dy = function (lon) {
+    return -180.0 <= lon ? lon <= 180.0 : false;
+  };
+  protoOf(ElevationFunctions).ey = function (zoom) {
+    return 0 <= zoom ? zoom <= 15 : false;
+  };
+  protoOf(ElevationFunctions).nx = function (pixel, tileSize) {
+    var x = pixel.px_1;
+    var y = pixel.qx_1;
+    var tileX = pixel.ox_1.yt_1;
+    var tileY = pixel.ox_1.zt_1;
+    var z = pixel.ox_1.au_1;
+    if (x < 0) {
+      x = x + tileSize | 0;
+      tileX = tileX - 1 | 0;
+    }
+    if (x >= tileSize) {
+      x = x - tileSize | 0;
+      tileX = tileX + 1 | 0;
+    }
+    if (y < 0) {
+      y = y + tileSize | 0;
+      tileY = tileY - 1 | 0;
+    }
+    if (y >= tileSize) {
+      y = y - tileSize | 0;
+      tileY = tileY + 1 | 0;
+    }
+    var maxTile = (1 << z) - 1 | 0;
+    tileX = coerceIn(tileX, 0, maxTile);
+    tileY = coerceIn(tileY, 0, maxTile);
+    return new Pixel(new TileCoordinates(tileX, tileY, z), x, y);
+  };
+  protoOf(ElevationFunctions).fy = function (coords, z) {
+    // Inline function 'kotlin.require' call
+    if (!this.cy(coords.ht())) {
+      var message = 'Invalid latitude: ' + formatNumber_0(ElevationFunctions_instance, coords.ht()) + '. Must be between -85.0511 and 85.0511';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    if (!this.dy(coords.it())) {
+      var message_0 = 'Invalid longitude: ' + formatNumber_0(ElevationFunctions_instance, coords.it()) + '. Must be between -180 and 180';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    // Inline function 'kotlin.require' call
+    if (!this.ey(z)) {
+      var message_1 = 'Invalid zoom level: ' + z + '. Must be between 0 and 15';
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+    var lat = this.by(coords.ht());
+    var n = 1 << z;
+    var xFloat = (coords.it() + 180.0) / 360.0 * n;
+    // Inline function 'kotlin.math.tan' call
+    var tmp = Math.tan(lat);
+    // Inline function 'kotlin.math.cos' call
+    // Inline function 'kotlin.math.ln' call
+    var x = tmp + 1.0 / Math.cos(lat);
+    var yFloat = (1.0 - Math.log(x) / 3.141592653589793) / 2.0 * n;
+    var maxTile = (1 << z) - 1 | 0;
+    // Inline function 'kotlin.math.floor' call
+    var tmp$ret$9 = Math.floor(xFloat);
+    var x_0 = coerceIn(numberToInt(tmp$ret$9), 0, maxTile);
+    // Inline function 'kotlin.math.floor' call
+    var tmp$ret$10 = Math.floor(yFloat);
+    var y = coerceIn(numberToInt(tmp$ret$10), 0, maxTile);
+    return new TileCoordinatesFloat(x_0, y, xFloat, yFloat, z);
+  };
+  protoOf(ElevationFunctions).xt = function (coords, z) {
+    var tile = this.fy(coords, z);
+    return new TileCoordinates(tile.gy_1, tile.hy_1, tile.ky_1);
+  };
+  protoOf(ElevationFunctions).ix = function (coords, z, tileSize) {
+    var tile = this.fy(coords, z);
+    // Inline function 'kotlin.math.floor' call
+    var x = (tile.iy_1 - tile.gy_1) * tileSize;
+    var tmp$ret$0 = Math.floor(x);
+    var px = coerceIn(numberToInt(tmp$ret$0), 0, tileSize - 1 | 0);
+    // Inline function 'kotlin.math.floor' call
+    var x_0 = (tile.jy_1 - tile.hy_1) * tileSize;
+    var tmp$ret$1 = Math.floor(x_0);
+    var py = coerceIn(numberToInt(tmp$ret$1), 0, tileSize - 1 | 0);
+    return new Pixel(new TileCoordinates(tile.gy_1, tile.hy_1, z), px, py);
+  };
+  protoOf(ElevationFunctions).jx = function (coords, z, tileSize) {
+    var tile = this.fy(coords, z);
+    var px = (tile.iy_1 - tile.gy_1) * tileSize;
+    var py = (tile.jy_1 - tile.hy_1) * tileSize;
+    return new PixelFloat(new TileCoordinates(tile.gy_1, tile.hy_1, z), px, py);
+  };
+  var ElevationFunctions_instance;
+  function ElevationFunctions_getInstance() {
+    return ElevationFunctions_instance;
+  }
+  function fetchAndDecodeTile$ref() {
+  }
+  protoOf(fetchAndDecodeTile$ref).ly = function (p0, $completion) {
+    return fetchAndDecodeTile(p0, $completion);
+  };
+  protoOf(fetchAndDecodeTile$ref).k6 = function (p1, $completion) {
+    return this.ly((!(p1 == null) ? typeof p1 === 'string' : false) ? p1 : THROW_CCE(), $completion);
+  };
+  function fetchAndDecodeTile$ref_0() {
+    var i = new fetchAndDecodeTile$ref();
+    var l = function (p0, $completion) {
+      return i.ly(p0, $completion);
+    };
+    l.callableName = 'fetchAndDecodeTile';
+    l.$arity = 1;
+    return l;
+  }
+  function ElevationProvider(config, fetcher) {
+    config = config === VOID ? new ElevationProviderConfig() : config;
+    var tmp;
+    if (fetcher === VOID) {
+      tmp = fetchAndDecodeTile$ref_0();
+    } else {
+      tmp = fetcher;
+    }
+    fetcher = tmp;
+    this.my_1 = config;
+    var containsArg = this.my_1.qy_1;
+    // Inline function 'kotlin.require' call
+    if (!(0 <= containsArg ? containsArg <= 15 : false)) {
+      var message = 'Invalid zoom level: ' + this.my_1.qy_1 + '. Must be an integer between 0 and 15';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.my_1.ry_1 > 0)) {
+      var message_0 = 'Invalid cache size: ' + this.my_1.ry_1 + '. Must be a positive integer';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    // Inline function 'kotlin.require' call
+    if (!(this.my_1.ty_1 > 0 && (this.my_1.ty_1 & (this.my_1.ty_1 - 1 | 0)) === 0)) {
+      var message_1 = 'Invalid tile size: ' + this.my_1.ty_1 + '. Must be a positive power of 2';
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+    this.ny_1 = new TileManager(this.my_1.sy_1, this.my_1.ry_1, fetcher);
+    this.oy_1 = new ElevationCalculator(this.ny_1, this.my_1.ty_1);
+    this.py_1 = new BatchCalculator(this.oy_1);
+  }
+  protoOf(ElevationProvider).vy = function (latitude, longitude, interpolation, $completion) {
+    return this.oy_1.gt(new LatLon(latitude, longitude), this.my_1.qy_1, interpolation, $completion);
+  };
+  protoOf(ElevationProvider).wy = function (coordinates, interpolation, $completion) {
+    return this.py_1.tu(coordinates, this.my_1.qy_1, interpolation, VOID, $completion);
+  };
+  protoOf(ElevationProvider).xy = function (coordinates, interpolation, $completion, $super) {
+    interpolation = interpolation === VOID ? true : interpolation;
+    return $super === VOID ? this.wy(coordinates, interpolation, $completion) : $super.wy.call(this, coordinates, interpolation, $completion);
+  };
+  protoOf(ElevationProvider).yy = function (path, step, minDistance, interpolation, smoothingOptions, filterOptions, $completion) {
+    return this.py_1.xu(path, this.my_1.qy_1, step, minDistance, interpolation, smoothingOptions, filterOptions, $completion);
+  };
+  function ElevationProviderConfig(zoomLevel, cacheSize, tileUrlTemplate, tileSize, attribution) {
+    zoomLevel = zoomLevel === VOID ? 12 : zoomLevel;
+    cacheSize = cacheSize === VOID ? 100 : cacheSize;
+    tileUrlTemplate = tileUrlTemplate === VOID ? 'https://tiles.mapterhorn.com/{z}/{x}/{y}.webp' : tileUrlTemplate;
+    tileSize = tileSize === VOID ? 512 : tileSize;
+    attribution = attribution === VOID ? new Attribution('Mapterhorn elevation data. See mapterhorn.com/attribution/ for details.', 'https://mapterhorn.com/attribution/') : attribution;
+    this.qy_1 = zoomLevel;
+    this.ry_1 = cacheSize;
+    this.sy_1 = tileUrlTemplate;
+    this.ty_1 = tileSize;
+    this.uy_1 = attribution;
+  }
+  protoOf(ElevationProviderConfig).toString = function () {
+    return 'ElevationProviderConfig(zoomLevel=' + this.qy_1 + ', cacheSize=' + this.ry_1 + ', tileUrlTemplate=' + this.sy_1 + ', tileSize=' + this.ty_1 + ', attribution=' + this.uy_1.toString() + ')';
+  };
+  protoOf(ElevationProviderConfig).hashCode = function () {
+    var result = this.qy_1;
+    result = imul(result, 31) + this.ry_1 | 0;
+    result = imul(result, 31) + getStringHashCode(this.sy_1) | 0;
+    result = imul(result, 31) + this.ty_1 | 0;
+    result = imul(result, 31) + this.uy_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(ElevationProviderConfig).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof ElevationProviderConfig))
+      return false;
+    if (!(this.qy_1 === other.qy_1))
+      return false;
+    if (!(this.ry_1 === other.ry_1))
+      return false;
+    if (!(this.sy_1 === other.sy_1))
+      return false;
+    if (!(this.ty_1 === other.ty_1))
+      return false;
+    if (!this.uy_1.equals(other.uy_1))
+      return false;
+    return true;
+  };
+  function Attribution(text, url) {
+    url = url === VOID ? null : url;
+    this.zy_1 = text;
+    this.az_1 = url;
+  }
+  protoOf(Attribution).toString = function () {
+    return 'Attribution(text=' + this.zy_1 + ', url=' + this.az_1 + ')';
+  };
+  protoOf(Attribution).hashCode = function () {
+    var result = getStringHashCode(this.zy_1);
+    result = imul(result, 31) + (this.az_1 == null ? 0 : getStringHashCode(this.az_1)) | 0;
+    return result;
+  };
+  protoOf(Attribution).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Attribution))
+      return false;
+    if (!(this.zy_1 === other.zy_1))
+      return false;
+    if (!(this.az_1 == other.az_1))
+      return false;
+    return true;
+  };
+  function computeSmoothedValue($this, index, points, distances, windowSize) {
+    var current = distances[index];
+    var startIndex = index;
+    while (startIndex > 0 && current - distances[startIndex - 1 | 0] <= windowSize) {
+      startIndex = startIndex - 1 | 0;
+    }
+    var endIndex = index;
+    while (endIndex < (points.l() - 1 | 0) && distances[endIndex + 1 | 0] - current <= windowSize) {
+      endIndex = endIndex + 1 | 0;
+    }
+    var totalWeight = 0.0;
+    var weightedSum = 0.0;
+    var inductionVariable = startIndex;
+    var last = endIndex;
+    if (inductionVariable <= last)
+      do {
+        var j = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.math.absoluteValue' call
+        var this_0 = distances[j] - current;
+        var d = Math.abs(this_0);
+        var weight = 1.0 - d / windowSize;
+        totalWeight = totalWeight + weight;
+        weightedSum = weightedSum + points.m(j).fv() * weight;
+      }
+       while (!(j === last));
+    return totalWeight > 0.0 ? weightedSum / totalWeight : points.m(index).fv();
+  }
+  function formatWindow($this, w) {
+    var asLong = numberToLong(w);
+    return toNumber(asLong) === w ? asLong.toString() : w.toString();
+  }
+  function ElevationSmoother() {
+  }
+  protoOf(ElevationSmoother).uu = function (points, windowSize) {
+    if (points.l() < 3)
+      return points;
+    // Inline function 'kotlin.require' call
+    if (!(windowSize > 0.0)) {
+      var message = 'Invalid window size: ' + formatWindow(ElevationSmoother_instance, windowSize) + '. Must be positive';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    var distances = Distance_instance.jv(points);
+    // Inline function 'kotlin.collections.List' call
+    // Inline function 'kotlin.collections.MutableList' call
+    var size = points.l();
+    var list = ArrayList_init_$Create$_0(size);
+    // Inline function 'kotlin.repeat' call
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var smoothed = computeSmoothedValue(ElevationSmoother_instance, index, points, distances, windowSize);
+        var tmp$ret$6 = new LatLonElevation(points.m(index).ht(), points.m(index).it(), smoothed);
+        list.h(tmp$ret$6);
+      }
+       while (inductionVariable < size);
+    return list;
+  };
+  var ElevationSmoother_instance;
+  function ElevationSmoother_getInstance() {
+    return ElevationSmoother_instance;
+  }
+  function Flux$forEachParallel$slambda$slambda($semaphore, $action, $item, resultContinuation) {
+    this.jz_1 = $semaphore;
+    this.kz_1 = $action;
+    this.lz_1 = $item;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(Flux$forEachParallel$slambda$slambda).pz = function ($this$async, $completion) {
+    var tmp = this.qz($this$async, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(Flux$forEachParallel$slambda$slambda).k6 = function (p1, $completion) {
+    return this.pz((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(Flux$forEachParallel$slambda$slambda).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 6;
+            this.nz_1 = this.jz_1;
+            this.u5_1 = 1;
+            suspendResult = this.nz_1.nq(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            this.oz_1 = Unit_instance;
+            this.u5_1 = 2;
+            continue $sm;
+          case 2:
+            this.v5_1 = 5;
+            this.u5_1 = 3;
+            suspendResult = this.kz_1(this.lz_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 3:
+            this.oz_1 = Unit_instance;
+            this.v5_1 = 6;
+            this.u5_1 = 4;
+            continue $sm;
+          case 4:
+            this.oz_1;
+            this.v5_1 = 6;
+            this.nz_1.hq();
+            return Unit_instance;
+          case 5:
+            this.v5_1 = 6;
+            var t = this.x5_1;
+            this.nz_1.hq();
+            throw t;
+          case 6:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 6) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(Flux$forEachParallel$slambda$slambda).qz = function ($this$async, completion) {
+    var i = new Flux$forEachParallel$slambda$slambda(this.jz_1, this.kz_1, this.lz_1, completion);
+    i.mz_1 = $this$async;
+    return i;
+  };
+  function Flux$forEachParallel$slambda$slambda_0($semaphore, $action, $item, resultContinuation) {
+    var i = new Flux$forEachParallel$slambda$slambda($semaphore, $action, $item, resultContinuation);
+    var l = function ($this$async, $completion) {
+      return i.pz($this$async, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function Flux$forEachParallel$slambda($maxParallel, $items, $action, resultContinuation) {
+    this.zz_1 = $maxParallel;
+    this.a10_1 = $items;
+    this.b10_1 = $action;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(Flux$forEachParallel$slambda).d10 = function ($this$coroutineScope, $completion) {
+    var tmp = this.qz($this$coroutineScope, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(Flux$forEachParallel$slambda).k6 = function (p1, $completion) {
+    return this.d10((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(Flux$forEachParallel$slambda).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            var semaphore = Semaphore(this.zz_1);
+            this.u5_1 = 1;
+            var this_0 = this.a10_1;
+            var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+            var _iterator__ex2g4s = this_0.i();
+            while (_iterator__ex2g4s.j()) {
+              var item = _iterator__ex2g4s.k();
+              destination.h(async(this.c10_1, VOID, VOID, Flux$forEachParallel$slambda$slambda_0(semaphore, this.b10_1, item, null)));
+            }
+
+            suspendResult = awaitAll(destination, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            return suspendResult;
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(Flux$forEachParallel$slambda).qz = function ($this$coroutineScope, completion) {
+    var i = new Flux$forEachParallel$slambda(this.zz_1, this.a10_1, this.b10_1, completion);
+    i.c10_1 = $this$coroutineScope;
+    return i;
+  };
+  function Flux$forEachParallel$slambda_0($maxParallel, $items, $action, resultContinuation) {
+    var i = new Flux$forEachParallel$slambda($maxParallel, $items, $action, resultContinuation);
+    var l = function ($this$coroutineScope, $completion) {
+      return i.d10($this$coroutineScope, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function $forEachParallelCOROUTINE$(_this__u8e3s4, items, maxParallel, action, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.m10_1 = _this__u8e3s4;
+    this.n10_1 = items;
+    this.o10_1 = maxParallel;
+    this.p10_1 = action;
+  }
+  protoOf($forEachParallelCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            if (!(this.o10_1 >= 1)) {
+              var message = 'maxParallel must be >= 1, got ' + this.o10_1;
+              throw IllegalArgumentException_init_$Create$(toString(message));
+            }
+
+            this.u5_1 = 1;
+            suspendResult = coroutineScope(Flux$forEachParallel$slambda_0(this.o10_1, this.n10_1, this.p10_1, null), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            return Unit_instance;
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function Flux() {
+  }
+  protoOf(Flux).bu = function (items, maxParallel, action, $completion) {
+    var tmp = new $forEachParallelCOROUTINE$(this, items, maxParallel, action, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  var Flux_instance;
+  function Flux_getInstance() {
+    return Flux_instance;
+  }
+  function $getCOROUTINE$(_this__u8e3s4, key, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.y10_1 = _this__u8e3s4;
+    this.z10_1 = key;
+  }
+  protoOf($getCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 12;
+            this.l11_1 = this.y10_1.p11_1;
+            this.k11_1 = null;
+            this.u5_1 = 1;
+            suspendResult = this.l11_1.fq(this.k11_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            var tmp$ret$2 = Unit_instance;
+            l$ret$3: do {
+              var tmp$ret$0;
+              l$ret$1: do {
+                var tmp_0;
+                try {
+                  var tmp0_safe_receiver = this.y10_1.q11_1.q2(this.z10_1);
+                  if (tmp0_safe_receiver == null)
+                    null;
+                  else {
+                    var tmp0 = this.y10_1.q11_1;
+                    var key = this.z10_1;
+                    tmp0.p2(key, tmp0_safe_receiver);
+                    tmp$ret$0 = tmp0_safe_receiver;
+                    break l$ret$1;
+                  }
+                  tmp$ret$2 = this.y10_1.r11_1.h1(this.z10_1);
+                  break l$ret$3;
+                } catch ($p) {
+                  var tmp_1;
+                  var t = $p;
+                  this.l11_1.rp(this.k11_1);
+                  throw t;
+                }
+              }
+               while (false);
+              var tmp_2 = tmp$ret$0;
+              this.l11_1.rp(this.k11_1);
+              return tmp_2;
+            }
+             while (false);
+            var tmp_3 = tmp$ret$2;
+            this.l11_1.rp(this.k11_1);
+            var existing = tmp_3;
+            if (!(existing == null)) {
+              this.u5_1 = 11;
+              suspendResult = existing.zh(this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.u5_1 = 2;
+              continue $sm;
+            }
+
+          case 2:
+            this.b11_1 = CompletableDeferred();
+            this.j11_1 = this.y10_1.p11_1;
+            this.i11_1 = null;
+            this.u5_1 = 3;
+            suspendResult = this.j11_1.fq(this.i11_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 3:
+            var tmp$ret$6 = Unit_instance;
+            l$ret$7: do {
+              var tmp$ret$4;
+              l$ret$5: do {
+                var tmp_4;
+                try {
+                  var tmp0_safe_receiver_0 = this.y10_1.q11_1.q2(this.z10_1);
+                  if (tmp0_safe_receiver_0 == null)
+                    null;
+                  else {
+                    var tmp0_0 = this.y10_1.q11_1;
+                    var key_0 = this.z10_1;
+                    tmp0_0.p2(key_0, tmp0_safe_receiver_0);
+                    tmp$ret$4 = tmp0_safe_receiver_0;
+                    break l$ret$5;
+                  }
+                  var raced = this.y10_1.r11_1.h1(this.z10_1);
+                  var tmp_5;
+                  if (!(raced == null)) {
+                    tmp_5 = raced;
+                  } else {
+                    var tmp0_1 = this.y10_1.r11_1;
+                    var tmp2 = this.z10_1;
+                    var value = this.b11_1;
+                    tmp0_1.p2(tmp2, value);
+                    tmp_5 = null;
+                  }
+                  tmp$ret$6 = tmp_5;
+                  break l$ret$7;
+                } catch ($p) {
+                  var tmp_6;
+                  var t_0 = $p;
+                  this.j11_1.rp(this.i11_1);
+                  throw t_0;
+                }
+              }
+               while (false);
+              var tmp_7 = tmp$ret$4;
+              this.j11_1.rp(this.i11_1);
+              return tmp_7;
+            }
+             while (false);
+            var tmp_8 = tmp$ret$6;
+            this.j11_1.rp(this.i11_1);
+            var awaitInstead = tmp_8;
+            if (!(awaitInstead == null)) {
+              this.u5_1 = 10;
+              suspendResult = awaitInstead.zh(this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.u5_1 = 4;
+              continue $sm;
+            }
+
+          case 4:
+            this.v5_1 = 6;
+            this.u5_1 = 5;
+            suspendResult = this.y10_1.n11_1(this.z10_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 5:
+            this.e11_1 = suspendResult;
+            this.v5_1 = 12;
+            this.u5_1 = 8;
+            continue $sm;
+          case 6:
+            this.v5_1 = 12;
+            var tmp_9 = this.x5_1;
+            if (tmp_9 instanceof Error) {
+              this.f11_1 = this.x5_1;
+              this.h11_1 = this.y10_1.p11_1;
+              this.g11_1 = null;
+              this.u5_1 = 7;
+              suspendResult = this.h11_1.fq(this.g11_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              throw this.x5_1;
+            }
+
+          case 7:
+            l$ret$9: do {
+              var tmp_10;
+              try {
+                this.y10_1.r11_1.q2(this.z10_1);
+                break l$ret$9;
+              } catch ($p) {
+                var tmp_11;
+                var t_1 = $p;
+                this.h11_1.rp(this.g11_1);
+                throw t_1;
+              }
+            }
+             while (false);
+            this.h11_1.rp(this.g11_1);
+            this.b11_1.xk(this.f11_1);
+            var tmp_12 = this;
+            throw this.f11_1;
+          case 8:
+            this.v5_1 = 12;
+            this.a11_1 = this.e11_1;
+            this.d11_1 = this.y10_1.p11_1;
+            this.c11_1 = null;
+            this.u5_1 = 9;
+            suspendResult = this.d11_1.fq(this.c11_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 9:
+            l$ret$11: do {
+              var tmp_13;
+              try {
+                this.y10_1.r11_1.q2(this.z10_1);
+                var tmp_14;
+                if (this.y10_1.q11_1.l() >= this.y10_1.m11_1) {
+                  var tmp0_2 = this.y10_1.q11_1;
+                  var key_1 = this.z10_1;
+                  tmp_14 = !(isInterface(tmp0_2, KtMap) ? tmp0_2 : THROW_CCE()).g1(key_1);
+                } else {
+                  tmp_14 = false;
+                }
+                if (tmp_14) {
+                  var iter = this.y10_1.q11_1.j1().i();
+                  var oldest = iter.k();
+                  var oldestValue = oldest.f1();
+                  iter.d2();
+                  var tmp0_safe_receiver_1 = this.y10_1.o11_1;
+                  if (tmp0_safe_receiver_1 == null)
+                    null;
+                  else
+                    tmp0_safe_receiver_1(oldestValue);
+                }
+                var tmp0_3 = this.y10_1.q11_1;
+                var tmp2_0 = this.z10_1;
+                var value_0 = this.a11_1;
+                tmp0_3.p2(tmp2_0, value_0);
+                break l$ret$11;
+              } catch ($p) {
+                var tmp_15;
+                var t_2 = $p;
+                this.d11_1.rp(this.c11_1);
+                throw t_2;
+              }
+            }
+             while (false);
+            this.d11_1.rp(this.c11_1);
+            this.b11_1.wk(this.a11_1);
+            return this.a11_1;
+          case 10:
+            return suspendResult;
+          case 11:
+            return suspendResult;
+          case 12:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 12) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function LruCache(maxSize, loader, onEvict) {
+    onEvict = onEvict === VOID ? null : onEvict;
+    this.m11_1 = maxSize;
+    this.n11_1 = loader;
+    this.o11_1 = onEvict;
+    // Inline function 'kotlin.require' call
+    if (!(this.m11_1 > 0)) {
+      var message = 'Cache size must be greater than 0';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    this.p11_1 = Mutex();
+    this.q11_1 = LinkedHashMap_init_$Create$();
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.r11_1 = LinkedHashMap_init_$Create$();
+  }
+  protoOf(LruCache).s11 = function (key, $completion) {
+    var tmp = new $getCOROUTINE$(this, key, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  function RawTile(width, height, rgba) {
+    this.t11_1 = width;
+    this.u11_1 = height;
+    this.v11_1 = rgba;
+    // Inline function 'kotlin.require' call
+    if (!(this.v11_1.length === imul(imul(this.t11_1, this.u11_1), 4))) {
+      var message = 'rgba size ' + this.v11_1.length + ' does not match width*height*4 (' + imul(imul(this.t11_1, this.u11_1), 4) + ')';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  protoOf(RawTile).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof RawTile))
+      return false;
+    return this.t11_1 === other.t11_1 && this.u11_1 === other.u11_1 && contentEquals(this.v11_1, other.v11_1);
+  };
+  protoOf(RawTile).hashCode = function () {
+    var result = this.t11_1;
+    result = imul(31, result) + this.u11_1 | 0;
+    result = imul(31, result) + contentHashCode(this.v11_1) | 0;
+    return result;
+  };
+  function Tile_init_$Init$(raw, $this) {
+    Tile.call($this, raw.t11_1, raw.u11_1, raw.v11_1);
+    return $this;
+  }
+  function Tile_init_$Create$(raw) {
+    return Tile_init_$Init$(raw, objectCreate(protoOf(Tile)));
+  }
+  function Companion() {
+  }
+  protoOf(Companion).w11 = function (r, g, b) {
+    var raw = r * 256.0 + g + b / 256.0 - 32768.0;
+    return round(raw * 100.0) / 100.0;
+  };
+  var Companion_instance;
+  function Companion_getInstance() {
+    return Companion_instance;
+  }
+  function Tile(width, height, rgba) {
+    this.vx_1 = width;
+    this.wx_1 = height;
+    this.xx_1 = rgba;
+    var tmp = this;
+    var tmp_0 = 0;
+    var tmp_1 = imul(this.vx_1, this.wx_1);
+    var tmp_2 = new Float64Array(tmp_1);
+    while (tmp_0 < tmp_1) {
+      tmp_2[tmp_0] = NaN;
+      tmp_0 = tmp_0 + 1 | 0;
+    }
+    tmp.yx_1 = tmp_2;
+    this.zx_1 = 0;
+  }
+  protoOf(Tile).ay = function (pixel) {
+    var containsUpper = this.vx_1;
+    var containsArg = pixel.px_1;
+    // Inline function 'kotlin.require' call
+    if (!(0 <= containsArg ? containsArg < containsUpper : false)) {
+      var message = 'Invalid x position: ' + pixel.px_1 + '. Must be between 0 and ' + (this.vx_1 - 1 | 0);
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    var containsUpper_0 = this.wx_1;
+    var containsArg_0 = pixel.qx_1;
+    // Inline function 'kotlin.require' call
+    if (!(0 <= containsArg_0 ? containsArg_0 < containsUpper_0 : false)) {
+      var message_0 = 'Invalid y position: ' + pixel.qx_1 + '. Must be between 0 and ' + (this.wx_1 - 1 | 0);
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    var idx = imul(pixel.qx_1, this.vx_1) + pixel.px_1 | 0;
+    var cached = this.yx_1[idx];
+    if (!isNaN_0(cached))
+      return cached;
+    var byteOffset = imul(idx, 4);
+    var r = this.xx_1[byteOffset] & 255;
+    var g = this.xx_1[byteOffset + 1 | 0] & 255;
+    var b = this.xx_1[byteOffset + 2 | 0] & 255;
+    var elevation = Companion_instance.w11(r, g, b);
+    this.yx_1[idx] = elevation;
+    this.zx_1 = this.zx_1 + 1 | 0;
+    return elevation;
+  };
+  function buildUrl($this, tc) {
+    return replace(replace(replace($this.rx_1, '{z}', tc.au_1.toString()), '{x}', tc.yt_1.toString()), '{y}', tc.zt_1.toString());
+  }
+  function fetchAndDecodeTile$ref_1() {
+  }
+  protoOf(fetchAndDecodeTile$ref_1).ly = function (p0, $completion) {
+    return fetchAndDecodeTile(p0, $completion);
+  };
+  protoOf(fetchAndDecodeTile$ref_1).k6 = function (p1, $completion) {
+    return this.ly((!(p1 == null) ? typeof p1 === 'string' : false) ? p1 : THROW_CCE(), $completion);
+  };
+  function fetchAndDecodeTile$ref_2() {
+    var i = new fetchAndDecodeTile$ref_1();
+    var l = function (p0, $completion) {
+      return i.ly(p0, $completion);
+    };
+    l.callableName = 'fetchAndDecodeTile';
+    l.$arity = 1;
+    return l;
+  }
+  function TileManager$cache$slambda(this$0, resultContinuation) {
+    this.f12_1 = this$0;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(TileManager$cache$slambda).h12 = function (tc, $completion) {
+    var tmp = this.i12(tc, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(TileManager$cache$slambda).k6 = function (p1, $completion) {
+    return this.h12(p1 instanceof TileCoordinates ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(TileManager$cache$slambda).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            this.u5_1 = 1;
+            suspendResult = this.f12_1.sx_1(buildUrl(this.f12_1, this.g12_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            var ARGUMENT = suspendResult;
+            return Tile_init_$Create$(ARGUMENT);
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(TileManager$cache$slambda).i12 = function (tc, completion) {
+    var i = new TileManager$cache$slambda(this.f12_1, completion);
+    i.g12_1 = tc;
+    return i;
+  };
+  function TileManager$cache$slambda_0(this$0, resultContinuation) {
+    var i = new TileManager$cache$slambda(this$0, resultContinuation);
+    var l = function (tc, $completion) {
+      return i.h12(tc, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function TileManager(urlTemplate, cacheSize, fetcher) {
+    var tmp;
+    if (fetcher === VOID) {
+      tmp = fetchAndDecodeTile$ref_2();
+    } else {
+      tmp = fetcher;
+    }
+    fetcher = tmp;
+    this.rx_1 = urlTemplate;
+    this.sx_1 = fetcher;
+    var tmp_0 = this;
+    tmp_0.tx_1 = new LruCache(cacheSize, TileManager$cache$slambda_0(this, null));
+  }
+  protoOf(TileManager).ux = function (tileCoords, $completion) {
+    return this.tx_1.s11(tileCoords, $completion);
+  };
+  function TileCoordinates(x, y, z) {
+    this.yt_1 = x;
+    this.zt_1 = y;
+    this.au_1 = z;
+  }
+  protoOf(TileCoordinates).toString = function () {
+    return 'TileCoordinates(x=' + this.yt_1 + ', y=' + this.zt_1 + ', z=' + this.au_1 + ')';
+  };
+  protoOf(TileCoordinates).hashCode = function () {
+    var result = this.yt_1;
+    result = imul(result, 31) + this.zt_1 | 0;
+    result = imul(result, 31) + this.au_1 | 0;
+    return result;
+  };
+  protoOf(TileCoordinates).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof TileCoordinates))
+      return false;
+    if (!(this.yt_1 === other.yt_1))
+      return false;
+    if (!(this.zt_1 === other.zt_1))
+      return false;
+    if (!(this.au_1 === other.au_1))
+      return false;
+    return true;
+  };
+  function Pixel(tile, x, y) {
+    this.ox_1 = tile;
+    this.px_1 = x;
+    this.qx_1 = y;
+  }
+  protoOf(Pixel).toString = function () {
+    return 'Pixel(tile=' + this.ox_1.toString() + ', x=' + this.px_1 + ', y=' + this.qx_1 + ')';
+  };
+  protoOf(Pixel).hashCode = function () {
+    var result = this.ox_1.hashCode();
+    result = imul(result, 31) + this.px_1 | 0;
+    result = imul(result, 31) + this.qx_1 | 0;
+    return result;
+  };
+  protoOf(Pixel).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Pixel))
+      return false;
+    if (!this.ox_1.equals(other.ox_1))
+      return false;
+    if (!(this.px_1 === other.px_1))
+      return false;
+    if (!(this.qx_1 === other.qx_1))
+      return false;
+    return true;
+  };
+  function PixelFloat(tile, x, y) {
+    this.kx_1 = tile;
+    this.lx_1 = x;
+    this.mx_1 = y;
+  }
+  protoOf(PixelFloat).toString = function () {
+    return 'PixelFloat(tile=' + this.kx_1.toString() + ', x=' + this.lx_1 + ', y=' + this.mx_1 + ')';
+  };
+  protoOf(PixelFloat).hashCode = function () {
+    var result = this.kx_1.hashCode();
+    result = imul(result, 31) + getNumberHashCode(this.lx_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.mx_1) | 0;
+    return result;
+  };
+  protoOf(PixelFloat).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof PixelFloat))
+      return false;
+    if (!this.kx_1.equals(other.kx_1))
+      return false;
+    if (!equals(this.lx_1, other.lx_1))
+      return false;
+    if (!equals(this.mx_1, other.mx_1))
+      return false;
+    return true;
+  };
+  function TileCoordinatesFloat(x, y, xFloat, yFloat, z) {
+    this.gy_1 = x;
+    this.hy_1 = y;
+    this.iy_1 = xFloat;
+    this.jy_1 = yFloat;
+    this.ky_1 = z;
+  }
+  protoOf(TileCoordinatesFloat).toString = function () {
+    return 'TileCoordinatesFloat(x=' + this.gy_1 + ', y=' + this.hy_1 + ', xFloat=' + this.iy_1 + ', yFloat=' + this.jy_1 + ', z=' + this.ky_1 + ')';
+  };
+  protoOf(TileCoordinatesFloat).hashCode = function () {
+    var result = this.gy_1;
+    result = imul(result, 31) + this.hy_1 | 0;
+    result = imul(result, 31) + getNumberHashCode(this.iy_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.jy_1) | 0;
+    result = imul(result, 31) + this.ky_1 | 0;
+    return result;
+  };
+  protoOf(TileCoordinatesFloat).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof TileCoordinatesFloat))
+      return false;
+    if (!(this.gy_1 === other.gy_1))
+      return false;
+    if (!(this.hy_1 === other.hy_1))
+      return false;
+    if (!equals(this.iy_1, other.iy_1))
+      return false;
+    if (!equals(this.jy_1, other.jy_1))
+      return false;
+    if (!(this.ky_1 === other.ky_1))
+      return false;
+    return true;
+  };
+  function Companion_0() {
+    Companion_instance_0 = this;
+    this.j12_1 = new Vector3D(0.0, 0.0, 0.0);
+  }
+  var Companion_instance_0;
+  function Companion_getInstance_0() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function Vector3D(x, y, z) {
+    Companion_getInstance_0();
+    this.lv_1 = x;
+    this.mv_1 = y;
+    this.nv_1 = z;
+  }
+  protoOf(Vector3D).k12 = function (other) {
+    var tmp0 = this.lv_1 - other.lv_1;
+    // Inline function 'kotlin.math.hypot' call
+    var y = this.mv_1 - other.mv_1;
+    var tmp0_0 = hypot(tmp0, y);
+    // Inline function 'kotlin.math.hypot' call
+    var y_0 = this.nv_1 - other.nv_1;
+    return hypot(tmp0_0, y_0);
+  };
+  protoOf(Vector3D).l12 = function (other) {
+    return new Vector3D(this.lv_1 - other.lv_1, this.mv_1 - other.mv_1, this.nv_1 - other.nv_1);
+  };
+  protoOf(Vector3D).m12 = function (other) {
+    return new Vector3D(this.lv_1 + other.lv_1, this.mv_1 + other.mv_1, this.nv_1 + other.nv_1);
+  };
+  protoOf(Vector3D).n12 = function (scalar) {
+    return new Vector3D(this.lv_1 * scalar, this.mv_1 * scalar, this.nv_1 * scalar);
+  };
+  protoOf(Vector3D).o12 = function (other) {
+    return this.lv_1 * other.lv_1 + this.mv_1 * other.mv_1 + this.nv_1 * other.nv_1;
+  };
+  protoOf(Vector3D).ov = function (segmentStart, segmentEnd) {
+    var segmentVector = segmentEnd.l12(segmentStart);
+    var segmentLengthSq = segmentVector.o12(segmentVector);
+    if (segmentLengthSq === 0.0)
+      return this.k12(segmentStart);
+    var pointVector = this.l12(segmentStart);
+    var projection = pointVector.o12(segmentVector) / segmentLengthSq;
+    var clamped = coerceIn_0(projection, 0.0, 1.0);
+    var closest = segmentStart.m12(segmentVector.n12(clamped));
+    return this.k12(closest);
+  };
+  protoOf(Vector3D).toString = function () {
+    return 'Vector3D(x=' + this.lv_1 + ', y=' + this.mv_1 + ', z=' + this.nv_1 + ')';
+  };
+  protoOf(Vector3D).hashCode = function () {
+    var result = getNumberHashCode(this.lv_1);
+    result = imul(result, 31) + getNumberHashCode(this.mv_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.nv_1) | 0;
+    return result;
+  };
+  protoOf(Vector3D).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Vector3D))
+      return false;
+    if (!equals(this.lv_1, other.lv_1))
+      return false;
+    if (!equals(this.mv_1, other.mv_1))
+      return false;
+    if (!equals(this.nv_1, other.nv_1))
+      return false;
+    return true;
+  };
+  function newElevationProvider(configDto) {
+    var defaults = new ElevationProviderConfig();
+    var tmp1_elvis_lhs = configDto == null ? null : configDto.zoomLevel;
+    var tmp = tmp1_elvis_lhs == null ? defaults.qy_1 : tmp1_elvis_lhs;
+    var tmp3_elvis_lhs = configDto == null ? null : configDto.cacheSize;
+    var tmp_0 = tmp3_elvis_lhs == null ? defaults.ry_1 : tmp3_elvis_lhs;
+    var tmp5_elvis_lhs = configDto == null ? null : configDto.tileUrlTemplate;
+    var tmp_1 = tmp5_elvis_lhs == null ? defaults.sy_1 : tmp5_elvis_lhs;
+    var tmp7_elvis_lhs = configDto == null ? null : configDto.tileSize;
+    var cfg = new ElevationProviderConfig(tmp, tmp_0, tmp_1, tmp7_elvis_lhs == null ? defaults.ty_1 : tmp7_elvis_lhs, defaults.uy_1);
+    return new ElevationProvider(cfg);
+  }
+  function getElevation(provider, latitude, longitude, interpolation) {
+    var tmp = GlobalScope_instance;
+    return promise(tmp, VOID, VOID, getElevation$slambda_0(provider, latitude, longitude, interpolation, null));
+  }
+  function getElevationsAlong(provider, path, options) {
+    var tmp = GlobalScope_instance;
+    return promise(tmp, VOID, VOID, getElevationsAlong$slambda_0(path, provider, options, null));
+  }
+  function toKotlin(_this__u8e3s4) {
+    return new SmoothingOptions(_this__u8e3s4.windowSize, _this__u8e3s4.enabled);
+  }
+  function toKotlin_0(_this__u8e3s4) {
+    return new FilterOptions(_this__u8e3s4.tolerance, _this__u8e3s4.zExaggeration, _this__u8e3s4.enabled);
+  }
+  function coordsEle(latitude, longitude, elevation) {
+    var o = {};
+    o.latitude = latitude;
+    o.longitude = longitude;
+    o.elevation = elevation;
+    // Inline function 'kotlin.js.unsafeCast' call
+    return o;
+  }
+  function getElevation$slambda($provider, $latitude, $longitude, $interpolation, resultContinuation) {
+    this.x12_1 = $provider;
+    this.y12_1 = $latitude;
+    this.z12_1 = $longitude;
+    this.a13_1 = $interpolation;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(getElevation$slambda).c13 = function ($this$promise, $completion) {
+    var tmp = this.qz($this$promise, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(getElevation$slambda).k6 = function (p1, $completion) {
+    return this.c13((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(getElevation$slambda).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            this.u5_1 = 1;
+            suspendResult = this.x12_1.vy(this.y12_1, this.z12_1, this.a13_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            return suspendResult;
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(getElevation$slambda).qz = function ($this$promise, completion) {
+    var i = new getElevation$slambda(this.x12_1, this.y12_1, this.z12_1, this.a13_1, completion);
+    i.b13_1 = $this$promise;
+    return i;
+  };
+  function getElevation$slambda_0($provider, $latitude, $longitude, $interpolation, resultContinuation) {
+    var i = new getElevation$slambda($provider, $latitude, $longitude, $interpolation, resultContinuation);
+    var l = function ($this$promise, $completion) {
+      return i.c13($this$promise, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function getElevationsAlong$slambda($path, $provider, $options, resultContinuation) {
+    this.l13_1 = $path;
+    this.m13_1 = $provider;
+    this.n13_1 = $options;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(getElevationsAlong$slambda).p13 = function ($this$promise, $completion) {
+    var tmp = this.qz($this$promise, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(getElevationsAlong$slambda).k6 = function (p1, $completion) {
+    return this.p13((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(getElevationsAlong$slambda).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            var this_0 = this.l13_1;
+            var destination = ArrayList_init_$Create$_0(this_0.length);
+            var inductionVariable = 0;
+            var last = this_0.length;
+            while (inductionVariable < last) {
+              var item = this_0[inductionVariable];
+              inductionVariable = inductionVariable + 1 | 0;
+              destination.h(new LatLon(item.latitude, item.longitude));
+            }
+
+            var coords = destination;
+            this.u5_1 = 1;
+            var tmp0_safe_receiver = this.n13_1;
+            var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.step;
+            var tmp_0 = tmp1_elvis_lhs == null ? 10.0 : tmp1_elvis_lhs;
+            var tmp2_safe_receiver = this.n13_1;
+            var tmp3_elvis_lhs = tmp2_safe_receiver == null ? null : tmp2_safe_receiver.minDistance;
+            var tmp_1 = tmp3_elvis_lhs == null ? 1.0 : tmp3_elvis_lhs;
+            var tmp4_safe_receiver = this.n13_1;
+            var tmp5_elvis_lhs = tmp4_safe_receiver == null ? null : tmp4_safe_receiver.interpolation;
+            var tmp_2 = tmp5_elvis_lhs == null ? true : tmp5_elvis_lhs;
+            var tmp6_safe_receiver = this.n13_1;
+            var tmp7_safe_receiver = tmp6_safe_receiver == null ? null : tmp6_safe_receiver.smoothingOptions;
+            var tmp_3 = tmp7_safe_receiver == null ? null : toKotlin(tmp7_safe_receiver);
+            var tmp8_safe_receiver = this.n13_1;
+            var tmp9_safe_receiver = tmp8_safe_receiver == null ? null : tmp8_safe_receiver.filterOptions;
+            suspendResult = this.m13_1.yy(coords, tmp_0, tmp_1, tmp_2, tmp_3, tmp9_safe_receiver == null ? null : toKotlin_0(tmp9_safe_receiver), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            var results = suspendResult;
+            var tmp_4 = 0;
+            var tmp_5 = results.l();
+            var tmp_6 = Array(tmp_5);
+            while (tmp_4 < tmp_5) {
+              var tmp_7 = tmp_4;
+              var c = results.m(tmp_7);
+              tmp_6[tmp_7] = coordsEle(c.ht(), c.it(), c.fv());
+              tmp_4 = tmp_4 + 1 | 0;
+            }
+
+            return tmp_6;
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(getElevationsAlong$slambda).qz = function ($this$promise, completion) {
+    var i = new getElevationsAlong$slambda(this.l13_1, this.m13_1, this.n13_1, completion);
+    i.o13_1 = $this$promise;
+    return i;
+  };
+  function getElevationsAlong$slambda_0($path, $provider, $options, resultContinuation) {
+    var i = new getElevationsAlong$slambda($path, $provider, $options, resultContinuation);
+    var l = function ($this$promise, $completion) {
+      return i.p13($this$promise, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function fetchAndDecodeTile(url, $completion) {
+    var tmp = new $fetchAndDecodeTileCOROUTINE$(url, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  }
+  function fetchUrl(url) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    return fetch(url);
+  }
+  function $fetchAndDecodeTileCOROUTINE$(url, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.y13_1 = url;
+  }
+  protoOf($fetchAndDecodeTileCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 4;
+            this.u5_1 = 1;
+            suspendResult = await_0(fetchUrl(this.y13_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            var res = suspendResult;
+            if (!res.ok) {
+              var message = 'Tile fetch failed for ' + this.y13_1 + ': HTTP ' + res.status;
+              throw IllegalStateException_init_$Create$_0(toString(message));
+            }
+
+            this.u5_1 = 2;
+            suspendResult = await_0(res.blob(), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 2:
+            var blob = suspendResult;
+            this.u5_1 = 3;
+            suspendResult = await_0(window.createImageBitmap(blob), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 3:
+            var bitmap = suspendResult;
+            l$ret$3: do {
+              var tmp$ret$0;
+              l$ret$1: do {
+                var tmp_0;
+                try {
+                  var tmp_1 = document.createElement('canvas');
+                  var canvas = tmp_1 instanceof HTMLCanvasElement ? tmp_1 : THROW_CCE();
+                  canvas.width = bitmap.width;
+                  canvas.height = bitmap.height;
+                  var tmp_2 = canvas.getContext('2d');
+                  var ctx = tmp_2 instanceof CanvasRenderingContext2D ? tmp_2 : THROW_CCE();
+                  ctx.drawImage(bitmap, 0.0, 0.0);
+                  var data = ctx.getImageData(0.0, 0.0, bitmap.width, bitmap.height);
+                  var src = data.data;
+                  var int8 = new Int8Array(src.buffer, src.byteOffset, src.byteLength);
+                  var rgba = int8;
+                  tmp$ret$0 = new RawTile(bitmap.width, bitmap.height, rgba);
+                  break l$ret$1;
+                } catch ($p) {
+                  var tmp_3;
+                  var t = $p;
+                  bitmap.close();
+                  throw t;
+                }
+              }
+               while (false);
+              var tmp_4 = tmp$ret$0;
+              bitmap.close();
+              return tmp_4;
+            }
+             while (false);
+            bitmap.close();
+            return Unit_instance;
+          case 4:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 4) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  //region block: init
+  Distance_instance = new Distance();
+  DouglasPeucker_instance = new DouglasPeucker();
+  EcefConverter_instance = new EcefConverter();
+  ElevationFunctions_instance = new ElevationFunctions();
+  ElevationSmoother_instance = new ElevationSmoother();
+  Flux_instance = new Flux();
+  Companion_instance = new Companion();
+  //endregion
+  //region block: exports
+  function $jsExportAll$(_) {
+    var io = _.io || (_.io = {});
+    var github = io.github || (io.github = {});
+    var glandais = github.glandais || (github.glandais = {});
+    var elevation = glandais.elevation || (glandais.elevation = {});
+    elevation.newElevationProvider = newElevationProvider;
+    elevation.getElevation = getElevation;
+    elevation.getElevationsAlong = getElevationsAlong;
+  }
+  $jsExportAll$(_);
+  _.$jsExportAll$ = $jsExportAll$;
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Distance_instance;
+  _.$_$.b = DouglasPeucker_instance;
+  _.$_$.c = ElevationSmoother_instance;
+  _.$_$.d = MathConstants_getInstance;
+  _.$_$.e = LatLonElevation;
+  _.$_$.f = LatLon;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=vcyclist-elevation.js.map