@glandais/vcyclist-elevation 0.0.0 → 1.1.0

package/README.md

@@ -0,0 +1,214 @@
+# vcyclist
+
+[![npm engine](https://img.shields.io/npm/v/@glandais/vcyclist-engine?label=%40glandais%2Fvcyclist-engine)](https://www.npmjs.com/package/@glandais/vcyclist-engine)
+[![npm elevation](https://img.shields.io/npm/v/@glandais/vcyclist-elevation?label=%40glandais%2Fvcyclist-elevation)](https://www.npmjs.com/package/@glandais/vcyclist-elevation)
+[![Maven Central](https://img.shields.io/maven-central/v/io.github.glandais/vcyclist-engine?label=io.github.glandais%3Avcyclist-engine)](https://central.sonatype.com/artifact/io.github.glandais/vcyclist-engine)
+
+Kotlin Multiplatform port of [`@glandais/virtual-cyclist`](https://github.com/glandais/virtual-cyclist):
+physics-based cycling simulator that turns a static GPS trace into a virtualized ride with
+realistic speeds, times and power estimates. Inspired by [gpx2web](https://github.com/glandais/gpx2web)
+(Java) for the physics model and the [`@glandais/elevation`](https://github.com/glandais/elevation)
+TypeScript library for elevation data.
+
+```
+                        ┌──────────────┐
+        sample.gpx ────▶│ GpxParser    │
+                        └──────┬───────┘
+                               ▼
+            ┌─────────────────────────────────────────┐
+            │  Enhancer (orchestrator)                │
+            │  ├─ PointPerDistance(-1, 30)            │
+            │  ├─ fixElevation (Terrarium tiles)*     │
+            │  ├─ PointPerDistance(1, 2)              │
+            │  ├─ smoothElevation (150 m kernel)      │
+            │  ├─ MaxSpeedComputer (cornering+braking)│
+            │  ├─ VirtualizeService (1 Hz physics)    │
+            │  ├─ PointPerSecond (uniform sampling)   │
+            │  └─ PathSimplifier (Douglas-Peucker 3D) │
+            └──────────────────┬──────────────────────┘
+                               ▼
+                        ┌──────────────┐
+                        │ GpxWriter    │────▶ output.gpx
+                        └──────────────┘
+            (*) optional — needs an ElevationProvider
+```
+
+## Modules
+
+| Module | Purpose | Targets |
+|---|---|---|
+| **`:elevation`** | Terrarium tile fetch + DEM lookup + Haversine + Douglas-Peucker 3D + triangular smoother. See [`elevation/README.md`](elevation/README.md). | JVM, JS Node, JS browser, Wasm browser |
+| **`:engine`** | Path model (36 fields × `DoubleArray`), physics (4 resistive `PowerProvider`s + cyclist input + `MaxSpeedComputer` + `VirtualizeService`), GPX I/O, `Enhancer` pipeline, JVM CLI. | JVM, JS Node, JS browser, Wasm browser |
+| **`:codegen`** | Tiny build-time helper that regenerates `GeneratedPath.kt` + `PointFieldAccessors.kt` from `PointField` (run only when the field list changes). | JVM only |
+
+## Install
+
+### npm (Kotlin/JS or Kotlin/Wasm consumers)
+
+```bash
+npm install @glandais/vcyclist-engine          # Kotlin/JS bundle
+npm install @glandais/vcyclist-engine-wasm     # Kotlin/Wasm bundle
+npm install @glandais/vcyclist-elevation       # Kotlin/JS bundle
+npm install @glandais/vcyclist-elevation-wasm  # Kotlin/Wasm bundle
+```
+
+### Gradle / Maven (JVM or KMP consumers)
+
+```kotlin
+// Gradle Kotlin DSL
+dependencies {
+    implementation("io.github.glandais:vcyclist-engine:1.0.0")    // pulls -jvm / -js / -wasm-js per target
+    implementation("io.github.glandais:vcyclist-elevation:1.0.0")
+}
+```
+
+Replace `1.0.0` by the latest version shown in the badges above. KMP consumers automatically
+get the platform-specific variant (`-jvm`, `-js`, `-wasm-js`) for their target.
+
+See [`docs/publishing.md`](docs/publishing.md) for the release process.
+
+## Quick start
+
+### Run the JVM CLI
+
+```bash
+# Enhance a GPX file with the default cyclist (80 kg / 280 W) and bike (Crr 0.004) :
+./gradlew :engine:run -Pargs="enhance path/to/input.gpx -o /tmp/output.gpx"
+```
+
+The CLI runs the full enhancement pipeline (no elevation correction — no HTTP) and writes the
+simulated trace back to a GPX file. See [`engine/src/jvmMain/.../EngineCli.kt`](engine/src/jvmMain/kotlin/io/github/glandais/engine/EngineCli.kt).
+
+### Try the browser demos (elevation only)
+
+```bash
+# Kotlin/Wasm demo
+./gradlew :elevation:wasmJsBrowserDevelopmentRun
+# Kotlin/JS demo (sibling, same UI)
+./gradlew :elevation:jsBrowserDevelopmentRun
+```
+
+Both demos share the [original TS demo](https://github.com/glandais/elevation) UI (Leaflet +
+Chart.js + GPX upload). See [`elevation/README.md`](elevation/README.md) for details.
+
+### Use from Kotlin
+
+```kotlin
+import io.github.glandais.engine.Enhancer
+import io.github.glandais.engine.gpx.GpxParser
+import io.github.glandais.engine.gpx.firstTrackAsPath
+
+suspend fun virtualize(xml: String): String {
+    val path = GpxParser.parse(xml).firstTrackAsPath()
+    val out = Enhancer.enhanceCourseDefault(path)  // pure physics, no HTTP
+    return io.github.glandais.engine.gpx.GpxWriter.write(
+        out.toGpxDocument(trackName = "virtualized")
+    )
+}
+```
+
+### Use from JavaScript / TypeScript
+
+`generateTypeScriptDefinitions()` is enabled on both `js(IR)` and `wasmJs`, so you get a
+`.d.ts` next to the bundle in `build/dist/{js,wasmJs}/productionExecutable/vcyclist-engine.d.{ts,mts}`.
+
+The Kotlin/JS variant (`@glandais/vcyclist-engine`, `@glandais/vcyclist-elevation`) runs
+**in both browser and Node.js / Bun**. The Wasm variants (`*-wasm`) are browser-only.
+
+#### Browser
+
+```js
+import { parseGpx, enhance, writeGpx, pathSize, pathTotalDistance } from '@glandais/vcyclist-engine';
+
+const handle = parseGpx(gpxXml);
+console.log('input points:', pathSize(handle));
+const out = await enhance(handle, null);                    // physics only, no HTTP
+console.log('output:', pathSize(out), pathTotalDistance(out), 'm');
+const xml = writeGpx(out);
+```
+
+#### Node.js / Bun (with elevation correction)
+
+```js
+import { parseGpx, enhance, writeGpx } from '@glandais/vcyclist-engine';
+
+const handle = parseGpx(gpxXml);
+const out = await enhance(handle, { fixElevation: true });  // fetches DEM tiles, decodes WebP
+const xml = writeGpx(out);
+```
+
+`enhance(..., { fixElevation: true })` auto-instantiates a default `ElevationProvider`
+(mapterhorn Terrarium tiles) and runs the full pipeline (densify → fix elevation → smooth →
+max speeds → virtualize → resample → simplify).
+
+On Node.js / Bun, tile decoding uses [`@jsquash/webp`](https://www.npmjs.com/package/@jsquash/webp)
+(a pure-WASM WebP decoder, ~50 KB, listed as a runtime `dependency` of
+`@glandais/vcyclist-engine` and `@glandais/vcyclist-elevation`). It is loaded lazily via
+`eval('require')`, so browser bundlers do not pull it into the browser build. Requires
+Node ≥ 18 (`globalThis.fetch` is built-in since Node 18 / Bun) ; Node 22+ recommended for
+ESM `require()` support.
+
+## Build & test
+
+```bash
+./gradlew check                         # full build + all tests on all targets
+./gradlew :engine:allTests              # engine tests across JVM / JS Node / JS browser / Wasm browser
+./gradlew :elevation:allTests           # elevation tests
+./gradlew :elevation:jvmTest --tests '*Integration*' \
+          -PINTEGRATION=1               # live HTTP tests against tiles.mapterhorn.com
+./gradlew ktlintCheck                   # lint
+```
+
+## Layout
+
+```
+vcyclist/
+├── settings.gradle.kts          # multi-module Gradle KMP project
+├── gradle/libs.versions.toml    # version catalog (Kotlin 2.3.21, coroutines 1.11, xmlutil 0.91, …)
+├── docs/
+│   ├── PLAN.md                  # task-by-task progress (Phases 1-2bis)
+│   ├── parity.md                # parity strategy vs the TS reference
+│   ├── elevation-integration.md # how to run live HTTP integration tests
+│   ├── kotlin-wasm-jvm-webp.md  # Kotlin/Wasm ↔ JS interop guide
+│   └── tasks/                   # one Markdown per implementation task (00-31, + bonus demos)
+├── elevation/                   # :elevation KMP module
+├── engine/                      # :engine KMP module (depends on :elevation)
+└── codegen/                     # :codegen JVM helper for Path accessor generation
+```
+
+## Status
+
+- ✅ **Phase 1** — `:elevation` module port (tasks 00-09) : Terrarium tiles, Haversine, ECEF,
+  Douglas-Peucker 3D, smoother, LRU cache + TileManager, `ElevationProvider`, live HTTP integration.
+- ✅ **Phase 2** — `:engine` module port (tasks 10-28) : Path model, Cyclist/Bike/Course,
+  GPX I/O, full physics, simulation, post-processing, `Enhancer`, CLI, `@JsExport` façades.
+- ✅ **Phase 2bis** — pipeline fidelity fixes (tasks 29-31) : `VirtualizeService` last-point
+  timestamp, `PointPerDistance` port, integration into `Enhancer`.
+- ✅ **Phase 3** — Node.js / Bun support (tasks 32-33) : runtime-detection in
+  `TileFetcher.js.kt` (browser path unchanged, Node path uses `globalThis.fetch` +
+  `@jsquash/webp` WASM decoder loaded via lazy `eval('require')`), webpack externals to keep
+  the browser bundle free of `@jsquash/webp`, `ElevationProvider` auto-instantiation in
+  `EngineJsApi.enhance` when `opts.fixElevation` is true (JS + Wasm façades), 6 jsTest classes
+  gated by `INTEGRATION=1`.
+
+Total `:engine` test coverage : 32 test classes / ~326 commonTest cases / 4 targets =
+~1300 green executions, plus JVM-only smoke tests for the CLI and the full pipeline.
+
+End-to-end smoke (after Phase 2bis) : sample.gpx (3569 source points, 130 km, ~4550 m gain)
+runs through the complete `Enhancer` pipeline in ~1.7 s on JVM, producing ~1000 simplified
+output points covering ~128.6 km / ~5.3 h of simulated ride.
+
+## Documentation
+
+- [`docs/PLAN.md`](docs/PLAN.md) — task-by-task plan with commit hashes for every step.
+- [`docs/tasks/`](docs/tasks/) — detailed Markdown spec for each task (00-31 + bonus demos).
+- [`docs/parity.md`](docs/parity.md) — TS↔Kotlin parity approach and tolerances.
+- [`docs/kotlin-wasm-jvm-webp.md`](docs/kotlin-wasm-jvm-webp.md) — Kotlin/Wasm ↔ JS interop
+  guide that underpins the `@JsExport` façades and the WebP tile decoding.
+- [`elevation/README.md`](elevation/README.md) — `:elevation` module details + browser demos.
+
+## License
+
+Apache License 2.0, aligned with the upstream `gpx2web` project. See the Maven Central POM
+metadata in `engine/build.gradle.kts` and `elevation/build.gradle.kts`. A top-level `LICENSE`
+file will be added before the first public release.

package/kotlin-kotlin-stdlib.js

@@ -46,6 +46,17 @@ if (typeof Array.prototype.fill === 'undefined') {
     Object.defineProperty(TypedArray.prototype, 'fill', {value: Array.prototype.fill});
   }
 });
+if (typeof Math.clz32 === 'undefined') {
+  Math.clz32 = function (log, LN2) {
+    return function (x) {
+      var asUint = x >>> 0;
+      if (asUint === 0) {
+        return 32;
+      }
+      return 31 - (log(asUint) / LN2 | 0) | 0; // the "| 0" acts like math.floor
+    };
+  }(Math.log, Math.LN2);
+}
 if (typeof Math.hypot === 'undefined') {
   Math.hypot = function () {
     var y = 0;
@@ -59,17 +70,6 @@ if (typeof Math.hypot === 'undefined') {
     return Math.sqrt(y);
   };
 }
-if (typeof Math.clz32 === 'undefined') {
-  Math.clz32 = function (log, LN2) {
-    return function (x) {
-      var asUint = x >>> 0;
-      if (asUint === 0) {
-        return 32;
-      }
-      return 31 - (log(asUint) / LN2 | 0) | 0; // the "| 0" acts like math.floor
-    };
-  }(Math.log, Math.LN2);
-}
 //endregion
 (function (factory) {
   if (typeof define === 'function' && define.amd)
@@ -186,6 +186,7 @@ if (typeof Math.clz32 === 'undefined') {
   initMetadataForClass(PrimitiveKClassImpl, 'PrimitiveKClassImpl', VOID, KClassImpl);
   initMetadataForObject(NothingKClassImpl, 'NothingKClassImpl', VOID, KClassImpl);
   initMetadataForClass(SimpleKClassImpl, 'SimpleKClassImpl', VOID, KClassImpl);
+  initMetadataForInterface(KProperty0, 'KProperty0');
   initMetadataForObject(PrimitiveClasses, 'PrimitiveClasses');
   initMetadataForClass(StringBuilder, 'StringBuilder', StringBuilder_init_$Create$_0, VOID, [CharSequence]);
   initMetadataForCompanion(Companion_3);
@@ -267,6 +268,8 @@ if (typeof Math.clz32 === 'undefined') {
   initMetadataForObject(State, 'State');
   initMetadataForClass(LinesIterator, 'LinesIterator');
   initMetadataForClass(lineSequence$$inlined$Sequence$1);
+  initMetadataForClass(UnsafeLazyImpl, 'UnsafeLazyImpl');
+  initMetadataForObject(UNINITIALIZED_VALUE, 'UNINITIALIZED_VALUE');
   initMetadataForCompanion(Companion_10);
   initMetadataForClass(Failure, 'Failure');
   initMetadataForClass(NotImplementedError, 'NotImplementedError', NotImplementedError, Error_0);
@@ -1559,6 +1562,60 @@ if (typeof Math.clz32 === 'undefined') {
   function numberRangeToNumber(start, endInclusive) {
     return new IntRange(start, endInclusive);
   }
+  function get_propertyRefClassMetadataCache() {
+    _init_properties_reflectRuntime_kt__5r4uu3();
+    return propertyRefClassMetadataCache;
+  }
+  var propertyRefClassMetadataCache;
+  function metadataObject() {
+    _init_properties_reflectRuntime_kt__5r4uu3();
+    return createMetadata('class', VOID, VOID, VOID, VOID, VOID);
+  }
+  function getPropertyCallableRef(name, paramCount, superType, getter, setter, linkageError) {
+    _init_properties_reflectRuntime_kt__5r4uu3();
+    getter.get = getter;
+    getter.set = setter;
+    getter.callableName = name;
+    // Inline function 'kotlin.js.unsafeCast' call
+    return getPropertyRefClass(getter, getKPropMetadata(paramCount, setter), superType);
+  }
+  function getPropertyRefClass(obj, metadata, superType) {
+    _init_properties_reflectRuntime_kt__5r4uu3();
+    obj.$metadata$ = metadata;
+    obj.constructor = obj;
+    var symbol = superType.Symbol;
+    if (symbol != null) {
+      // Inline function 'kotlin.js.asDynamic' call
+      obj[symbol] = true;
+    }
+    Object.assign(obj, superType.prototype);
+    return obj;
+  }
+  function getKPropMetadata(paramCount, setter) {
+    _init_properties_reflectRuntime_kt__5r4uu3();
+    return get_propertyRefClassMetadataCache()[paramCount][setter == null ? 0 : 1];
+  }
+  var properties_initialized_reflectRuntime_kt_inkhwd;
+  function _init_properties_reflectRuntime_kt__5r4uu3() {
+    if (!properties_initialized_reflectRuntime_kt_inkhwd) {
+      properties_initialized_reflectRuntime_kt_inkhwd = true;
+      // Inline function 'kotlin.arrayOf' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var tmp = [metadataObject(), metadataObject()];
+      // Inline function 'kotlin.arrayOf' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var tmp_0 = [metadataObject(), metadataObject()];
+      // Inline function 'kotlin.arrayOf' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      // Inline function 'kotlin.arrayOf' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      propertyRefClassMetadataCache = [tmp, tmp_0, [metadataObject(), metadataObject()]];
+    }
+  }
   function isArrayish(o) {
     return isJsArray(o) || isView(o);
   }
@@ -3173,6 +3230,9 @@ if (typeof Math.clz32 === 'undefined') {
   function ClassCastException() {
     captureStack(this, ClassCastException);
   }
+  function lazy(initializer) {
+    return new UnsafeLazyImpl(initializer);
+  }
   function fillFrom(src, dst) {
     var srcLen = src.length;
     var dstLen = dst.length;
@@ -3301,6 +3361,8 @@ if (typeof Math.clz32 === 'undefined') {
   protoOf(SimpleKClassImpl).k6 = function () {
     return this.r6_1;
   };
+  function KProperty0() {
+  }
   function get_functionClasses() {
     _init_properties_primitives_kt__3fums4();
     return functionClasses;
@@ -5348,6 +5410,29 @@ if (typeof Math.clz32 === 'undefined') {
   protoOf(lineSequence$$inlined$Sequence$1).g = function () {
     return new LinesIterator(this.r9_1);
   };
+  function UnsafeLazyImpl(initializer) {
+    this.s9_1 = initializer;
+    this.t9_1 = UNINITIALIZED_VALUE_instance;
+  }
+  protoOf(UnsafeLazyImpl).r = function () {
+    if (this.t9_1 === UNINITIALIZED_VALUE_instance) {
+      this.t9_1 = ensureNotNull(this.s9_1)();
+      this.s9_1 = null;
+    }
+    return this.t9_1;
+  };
+  protoOf(UnsafeLazyImpl).u9 = function () {
+    return !(this.t9_1 === UNINITIALIZED_VALUE_instance);
+  };
+  protoOf(UnsafeLazyImpl).toString = function () {
+    return this.u9() ? toString_0(this.r()) : 'Lazy value not initialized yet.';
+  };
+  function UNINITIALIZED_VALUE() {
+  }
+  var UNINITIALIZED_VALUE_instance;
+  function UNINITIALIZED_VALUE_getInstance() {
+    return UNINITIALIZED_VALUE_instance;
+  }
   function _Result___init__impl__xyqfz8(value) {
     return value;
   }
@@ -5361,7 +5446,7 @@ if (typeof Math.clz32 === 'undefined') {
   function Result__exceptionOrNull_impl_p6xea9($this) {
     var tmp;
     if (_Result___get_value__impl__bjfvqg($this) instanceof Failure) {
-      tmp = _Result___get_value__impl__bjfvqg($this).s9_1;
+      tmp = _Result___get_value__impl__bjfvqg($this).v9_1;
     } else {
       tmp = null;
     }
@@ -5374,22 +5459,22 @@ if (typeof Math.clz32 === 'undefined') {
     return Companion_instance_10;
   }
   function Failure(exception) {
-    this.s9_1 = exception;
+    this.v9_1 = exception;
   }
   protoOf(Failure).equals = function (other) {
     var tmp;
     if (other instanceof Failure) {
-      tmp = equals(this.s9_1, other.s9_1);
+      tmp = equals(this.v9_1, other.v9_1);
     } else {
       tmp = false;
     }
     return tmp;
   };
   protoOf(Failure).hashCode = function () {
-    return hashCode_0(this.s9_1);
+    return hashCode_0(this.v9_1);
   };
   protoOf(Failure).toString = function () {
-    return 'Failure(' + this.s9_1.toString() + ')';
+    return 'Failure(' + this.v9_1.toString() + ')';
   };
   function createFailure(exception) {
     return new Failure(exception);
@@ -5419,6 +5504,7 @@ if (typeof Math.clz32 === 'undefined') {
   Key_instance = new Key();
   Companion_instance_9 = new Companion_9();
   State_instance = new State();
+  UNINITIALIZED_VALUE_instance = new UNINITIALIZED_VALUE();
   Companion_instance_10 = new Companion_10();
   //endregion
   //region block: exports
@@ -5502,41 +5588,45 @@ if (typeof Math.clz32 === 'undefined') {
   _.$_$.y2 = equals;
   _.$_$.z2 = getBooleanHashCode;
   _.$_$.a3 = getNumberHashCode;
-  _.$_$.b3 = getStringHashCode;
-  _.$_$.c3 = hashCode_0;
-  _.$_$.d3 = initMetadataForClass;
-  _.$_$.e3 = initMetadataForCompanion;
-  _.$_$.f3 = initMetadataForCoroutine;
-  _.$_$.g3 = initMetadataForFunctionReference;
-  _.$_$.h3 = initMetadataForInterface;
-  _.$_$.i3 = initMetadataForLambda;
-  _.$_$.j3 = initMetadataForObject;
-  _.$_$.k3 = isInterface;
-  _.$_$.l3 = numberToInt;
-  _.$_$.m3 = objectCreate;
-  _.$_$.n3 = protoOf;
-  _.$_$.o3 = toString_1;
-  _.$_$.p3 = round;
-  _.$_$.q3 = coerceIn;
-  _.$_$.r3 = coerceIn_0;
-  _.$_$.s3 = getKClassFromExpression;
-  _.$_$.t3 = replace;
-  _.$_$.u3 = toLongOrNull;
-  _.$_$.v3 = Enum;
-  _.$_$.w3 = Error_0;
-  _.$_$.x3 = Exception;
-  _.$_$.y3 = Long;
-  _.$_$.z3 = RuntimeException;
-  _.$_$.a4 = THROW_CCE;
-  _.$_$.b4 = Unit;
-  _.$_$.c4 = UnsupportedOperationException;
-  _.$_$.d4 = addSuppressed;
-  _.$_$.e4 = createFailure;
-  _.$_$.f4 = ensureNotNull;
-  _.$_$.g4 = isNaN_0;
-  _.$_$.h4 = noWhenBranchMatchedException;
-  _.$_$.i4 = stackTraceToString;
-  _.$_$.j4 = toString_0;
+  _.$_$.b3 = getPropertyCallableRef;
+  _.$_$.c3 = getStringHashCode;
+  _.$_$.d3 = hashCode_0;
+  _.$_$.e3 = initMetadataForClass;
+  _.$_$.f3 = initMetadataForCompanion;
+  _.$_$.g3 = initMetadataForCoroutine;
+  _.$_$.h3 = initMetadataForFunctionReference;
+  _.$_$.i3 = initMetadataForInterface;
+  _.$_$.j3 = initMetadataForLambda;
+  _.$_$.k3 = initMetadataForObject;
+  _.$_$.l3 = isInterface;
+  _.$_$.m3 = isNumber;
+  _.$_$.n3 = numberToInt;
+  _.$_$.o3 = objectCreate;
+  _.$_$.p3 = protoOf;
+  _.$_$.q3 = toString_1;
+  _.$_$.r3 = round;
+  _.$_$.s3 = coerceIn;
+  _.$_$.t3 = coerceIn_0;
+  _.$_$.u3 = getKClassFromExpression;
+  _.$_$.v3 = KProperty0;
+  _.$_$.w3 = replace;
+  _.$_$.x3 = toLongOrNull;
+  _.$_$.y3 = Enum;
+  _.$_$.z3 = Error_0;
+  _.$_$.a4 = Exception;
+  _.$_$.b4 = Long;
+  _.$_$.c4 = RuntimeException;
+  _.$_$.d4 = THROW_CCE;
+  _.$_$.e4 = Unit;
+  _.$_$.f4 = UnsupportedOperationException;
+  _.$_$.g4 = addSuppressed;
+  _.$_$.h4 = createFailure;
+  _.$_$.i4 = ensureNotNull;
+  _.$_$.j4 = isNaN_0;
+  _.$_$.k4 = lazy;
+  _.$_$.l4 = noWhenBranchMatchedException;
+  _.$_$.m4 = stackTraceToString;
+  _.$_$.n4 = toString_0;
   //endregion
   return _;
 }));