@attocash/commons-test 6.0.0

package/kotlin-kotlin-stdlib/kotlin/reflect/js/internal/primitives.mjs

@@ -0,0 +1,296 @@
+import {
+  isNumberiramasdbon0i as isNumber,
+  isArray1hxjqtqy632bc as isArray,
+  isBooleanArray35llghle4c6w1 as isBooleanArray,
+  isCharArray21auq5hbrg68m as isCharArray,
+  isByteArray4nnzfn1x4o3w as isByteArray,
+  isShortArraywz30zxwtqi8h as isShortArray,
+  isIntArrayeijsubfngq38 as isIntArray,
+  isLongArray2fdt3z7yu3ef as isLongArray,
+  isFloatArrayjjscnqphw92j as isFloatArray,
+  isDoubleArray1wyh4nyf7pjxn as isDoubleArray,
+} from '../../../js/typeCheckUtils.mjs';
+import {
+  PrimitiveKClassImpl1fv46nzfav2pd as PrimitiveKClassImpl,
+  NothingKClassImpl_getInstance1v9lrhbzi4zr5 as NothingKClassImpl_getInstance,
+} from './KClassImpl.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../js/void.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../Unit.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../../../js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_functionClasses() {
+  _init_properties_primitives_kt__3fums4();
+  return functionClasses;
+}
+var functionClasses;
+function PrimitiveClasses$anyClass$lambda(it) {
+  return !(it == null);
+}
+function PrimitiveClasses$numberClass$lambda(it) {
+  return isNumber(it);
+}
+function PrimitiveClasses$booleanClass$lambda(it) {
+  return !(it == null) ? typeof it === 'boolean' : false;
+}
+function PrimitiveClasses$byteClass$lambda(it) {
+  return !(it == null) ? typeof it === 'number' : false;
+}
+function PrimitiveClasses$shortClass$lambda(it) {
+  return !(it == null) ? typeof it === 'number' : false;
+}
+function PrimitiveClasses$intClass$lambda(it) {
+  return !(it == null) ? typeof it === 'number' : false;
+}
+function PrimitiveClasses$longClass$lambda(it) {
+  return !(it == null) ? typeof it === 'bigint' : false;
+}
+function PrimitiveClasses$floatClass$lambda(it) {
+  return !(it == null) ? typeof it === 'number' : false;
+}
+function PrimitiveClasses$doubleClass$lambda(it) {
+  return !(it == null) ? typeof it === 'number' : false;
+}
+function PrimitiveClasses$arrayClass$lambda(it) {
+  return !(it == null) ? isArray(it) : false;
+}
+function PrimitiveClasses$stringClass$lambda(it) {
+  return !(it == null) ? typeof it === 'string' : false;
+}
+function PrimitiveClasses$throwableClass$lambda(it) {
+  return it instanceof Error;
+}
+function PrimitiveClasses$booleanArrayClass$lambda(it) {
+  return !(it == null) ? isBooleanArray(it) : false;
+}
+function PrimitiveClasses$charArrayClass$lambda(it) {
+  return !(it == null) ? isCharArray(it) : false;
+}
+function PrimitiveClasses$byteArrayClass$lambda(it) {
+  return !(it == null) ? isByteArray(it) : false;
+}
+function PrimitiveClasses$shortArrayClass$lambda(it) {
+  return !(it == null) ? isShortArray(it) : false;
+}
+function PrimitiveClasses$intArrayClass$lambda(it) {
+  return !(it == null) ? isIntArray(it) : false;
+}
+function PrimitiveClasses$longArrayClass$lambda(it) {
+  return !(it == null) ? isLongArray(it) : false;
+}
+function PrimitiveClasses$floatArrayClass$lambda(it) {
+  return !(it == null) ? isFloatArray(it) : false;
+}
+function PrimitiveClasses$doubleArrayClass$lambda(it) {
+  return !(it == null) ? isDoubleArray(it) : false;
+}
+function PrimitiveClasses$functionClass$lambda($arity) {
+  return (it) => {
+    var tmp;
+    if (typeof it === 'function') {
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp = it.length === $arity;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+}
+var PrimitiveClassesClass;
+function PrimitiveClasses() {
+  if (PrimitiveClassesClass === VOID) {
+    class $ {
+      constructor() {
+        PrimitiveClasses_instance = this;
+        var tmp = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_0 = Object;
+        tmp.anyClass = new (PrimitiveKClassImpl())(tmp_0, 'Any', PrimitiveClasses$anyClass$lambda);
+        var tmp_1 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_2 = Number;
+        tmp_1.numberClass = new (PrimitiveKClassImpl())(tmp_2, 'Number', PrimitiveClasses$numberClass$lambda);
+        this.nothingClass = NothingKClassImpl_getInstance();
+        var tmp_3 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_4 = Boolean;
+        tmp_3.booleanClass = new (PrimitiveKClassImpl())(tmp_4, 'Boolean', PrimitiveClasses$booleanClass$lambda);
+        var tmp_5 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_6 = Number;
+        tmp_5.byteClass = new (PrimitiveKClassImpl())(tmp_6, 'Byte', PrimitiveClasses$byteClass$lambda);
+        var tmp_7 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_8 = Number;
+        tmp_7.shortClass = new (PrimitiveKClassImpl())(tmp_8, 'Short', PrimitiveClasses$shortClass$lambda);
+        var tmp_9 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_10 = Number;
+        tmp_9.intClass = new (PrimitiveKClassImpl())(tmp_10, 'Int', PrimitiveClasses$intClass$lambda);
+        var tmp_11 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        var tmp_12 = typeof BigInt === 'undefined' ? VOID : BigInt;
+        tmp_11.longClass = new (PrimitiveKClassImpl())(tmp_12, 'Long', PrimitiveClasses$longClass$lambda);
+        var tmp_13 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_14 = Number;
+        tmp_13.floatClass = new (PrimitiveKClassImpl())(tmp_14, 'Float', PrimitiveClasses$floatClass$lambda);
+        var tmp_15 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_16 = Number;
+        tmp_15.doubleClass = new (PrimitiveKClassImpl())(tmp_16, 'Double', PrimitiveClasses$doubleClass$lambda);
+        var tmp_17 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_18 = Array;
+        tmp_17.arrayClass = new (PrimitiveKClassImpl())(tmp_18, 'Array', PrimitiveClasses$arrayClass$lambda);
+        var tmp_19 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_20 = String;
+        tmp_19.stringClass = new (PrimitiveKClassImpl())(tmp_20, 'String', PrimitiveClasses$stringClass$lambda);
+        var tmp_21 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_22 = Error;
+        tmp_21.throwableClass = new (PrimitiveKClassImpl())(tmp_22, 'Throwable', PrimitiveClasses$throwableClass$lambda);
+        var tmp_23 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_24 = Array;
+        tmp_23.booleanArrayClass = new (PrimitiveKClassImpl())(tmp_24, 'BooleanArray', PrimitiveClasses$booleanArrayClass$lambda);
+        var tmp_25 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_26 = Uint16Array;
+        tmp_25.charArrayClass = new (PrimitiveKClassImpl())(tmp_26, 'CharArray', PrimitiveClasses$charArrayClass$lambda);
+        var tmp_27 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_28 = Int8Array;
+        tmp_27.byteArrayClass = new (PrimitiveKClassImpl())(tmp_28, 'ByteArray', PrimitiveClasses$byteArrayClass$lambda);
+        var tmp_29 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_30 = Int16Array;
+        tmp_29.shortArrayClass = new (PrimitiveKClassImpl())(tmp_30, 'ShortArray', PrimitiveClasses$shortArrayClass$lambda);
+        var tmp_31 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_32 = Int32Array;
+        tmp_31.intArrayClass = new (PrimitiveKClassImpl())(tmp_32, 'IntArray', PrimitiveClasses$intArrayClass$lambda);
+        var tmp_33 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_34 = Array;
+        tmp_33.longArrayClass = new (PrimitiveKClassImpl())(tmp_34, 'LongArray', PrimitiveClasses$longArrayClass$lambda);
+        var tmp_35 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_36 = Float32Array;
+        tmp_35.floatArrayClass = new (PrimitiveKClassImpl())(tmp_36, 'FloatArray', PrimitiveClasses$floatArrayClass$lambda);
+        var tmp_37 = this;
+        // Inline function 'kotlin.js.unsafeCast' call
+        var tmp_38 = Float64Array;
+        tmp_37.doubleArrayClass = new (PrimitiveKClassImpl())(tmp_38, 'DoubleArray', PrimitiveClasses$doubleArrayClass$lambda);
+      }
+      mf() {
+        return this.anyClass;
+      }
+      nf() {
+        return this.numberClass;
+      }
+      of() {
+        return this.nothingClass;
+      }
+      pf() {
+        return this.booleanClass;
+      }
+      qf() {
+        return this.byteClass;
+      }
+      rf() {
+        return this.shortClass;
+      }
+      sf() {
+        return this.intClass;
+      }
+      tf() {
+        return this.longClass;
+      }
+      uf() {
+        return this.floatClass;
+      }
+      vf() {
+        return this.doubleClass;
+      }
+      wf() {
+        return this.arrayClass;
+      }
+      xf() {
+        return this.stringClass;
+      }
+      yf() {
+        return this.throwableClass;
+      }
+      zf() {
+        return this.booleanArrayClass;
+      }
+      ag() {
+        return this.charArrayClass;
+      }
+      bg() {
+        return this.byteArrayClass;
+      }
+      cg() {
+        return this.shortArrayClass;
+      }
+      dg() {
+        return this.intArrayClass;
+      }
+      eg() {
+        return this.longArrayClass;
+      }
+      fg() {
+        return this.floatArrayClass;
+      }
+      gg() {
+        return this.doubleArrayClass;
+      }
+      functionClass(arity) {
+        var tmp0_elvis_lhs = get_functionClasses()[arity];
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          // Inline function 'kotlin.run' call
+          // Inline function 'kotlin.js.unsafeCast' call
+          var tmp_0 = Function;
+          var tmp_1 = 'Function' + arity;
+          var result = new (PrimitiveKClassImpl())(tmp_0, tmp_1, PrimitiveClasses$functionClass$lambda(arity));
+          // Inline function 'kotlin.js.asDynamic' call
+          get_functionClasses()[arity] = result;
+          tmp = result;
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
+      }
+    }
+    initMetadataForObject($, 'PrimitiveClasses');
+    PrimitiveClassesClass = $;
+  }
+  return PrimitiveClassesClass;
+}
+var PrimitiveClasses_instance;
+function PrimitiveClasses_getInstance() {
+  if (PrimitiveClasses_instance === VOID)
+    new (PrimitiveClasses())();
+  return PrimitiveClasses_instance;
+}
+var properties_initialized_primitives_kt_jle18u;
+function _init_properties_primitives_kt__3fums4() {
+  if (!properties_initialized_primitives_kt_jle18u) {
+    properties_initialized_primitives_kt_jle18u = true;
+    // Inline function 'kotlin.arrayOfNulls' call
+    functionClasses = Array(0);
+  }
+}
+//region block: exports
+export {
+  PrimitiveClasses_getInstance as PrimitiveClasses_getInstance2v63zn04dtq03,
+};
+//endregion
+
+//# sourceMappingURL=primitives.mjs.map

package/kotlin-kotlin-stdlib/kotlin/reflect/js/internal/primitives.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/reflect/primitives.kt","js/builtins/Library.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-functionClasses>","PrimitiveClasses$anyClass$lambda","PrimitiveClasses$numberClass$lambda","PrimitiveClasses$booleanClass$lambda","PrimitiveClasses$byteClass$lambda","PrimitiveClasses$shortClass$lambda","PrimitiveClasses$intClass$lambda","PrimitiveClasses$longClass$lambda","PrimitiveClasses$floatClass$lambda","PrimitiveClasses$doubleClass$lambda","PrimitiveClasses$arrayClass$lambda","PrimitiveClasses$stringClass$lambda","PrimitiveClasses$throwableClass$lambda","PrimitiveClasses$booleanArrayClass$lambda","PrimitiveClasses$charArrayClass$lambda","PrimitiveClasses$byteArrayClass$lambda","PrimitiveClasses$shortArrayClass$lambda","PrimitiveClasses$intArrayClass$lambda","PrimitiveClasses$longArrayClass$lambda","PrimitiveClasses$floatArrayClass$lambda","PrimitiveClasses$doubleArrayClass$lambda","PrimitiveClasses$functionClass$lambda","$arity","PrimitiveClasses$functionClass$lambda$lambda","<get-anyClass>","<get-numberClass>","<get-nothingClass>","<get-booleanClass>","<get-byteClass>","<get-shortClass>","<get-intClass>","<get-longClass>","<get-floatClass>","<get-doubleClass>","<get-arrayClass>","<get-stringClass>","<get-throwableClass>","<get-booleanArrayClass>","<get-charArrayClass>","<get-byteArrayClass>","<get-shortArrayClass>","<get-intArrayClass>","<get-longArrayClass>","<get-floatArrayClass>","<get-doubleArrayClass>","functionClass","arity","result","<init properties primitives.kt>"],"mappings":"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"}

package/kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs

@@ -0,0 +1,141 @@
+import { PrimitiveClasses_getInstance2v63zn04dtq03 as PrimitiveClasses_getInstance } from './primitives.mjs';
+import { SimpleKClassImpl1arbnmvef0y44 as SimpleKClassImpl } from './KClassImpl.mjs';
+import {
+  isArray1hxjqtqy632bc as isArray,
+  isInterface3d6p8outrmvmk as isInterface,
+  isDoubleArray1wyh4nyf7pjxn as isDoubleArray,
+  isFloatArrayjjscnqphw92j as isFloatArray,
+  isLongArray2fdt3z7yu3ef as isLongArray,
+  isIntArrayeijsubfngq38 as isIntArray,
+  isShortArraywz30zxwtqi8h as isShortArray,
+  isByteArray4nnzfn1x4o3w as isByteArray,
+  isCharArray21auq5hbrg68m as isCharArray,
+  isBooleanArray35llghle4c6w1 as isBooleanArray,
+} from '../../../js/typeCheckUtils.mjs';
+import { KClass1cc9rfeybg8hs as KClass } from '../../KClassJs.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function getKClass(jClass) {
+  if (jClass === String) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return PrimitiveClasses_getInstance().stringClass;
+  }
+  // Inline function 'kotlin.js.asDynamic' call
+  var metadata = jClass.$metadata$;
+  var tmp;
+  if (metadata != null) {
+    var tmp_0;
+    if (metadata.$kClass$ == null) {
+      var kClass = new (SimpleKClassImpl())(jClass);
+      metadata.$kClass$ = kClass;
+      tmp_0 = kClass;
+    } else {
+      tmp_0 = metadata.$kClass$;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = new (SimpleKClassImpl())(jClass);
+  }
+  return tmp;
+}
+function getKClassFromExpression(e) {
+  var tmp;
+  switch (typeof e) {
+    case 'string':
+      tmp = PrimitiveClasses_getInstance().stringClass;
+      break;
+    case 'number':
+      var tmp_0;
+      // Inline function 'kotlin.js.jsBitwiseOr' call
+
+      // Inline function 'kotlin.js.asDynamic' call
+
+      if ((e | 0) === e) {
+        tmp_0 = PrimitiveClasses_getInstance().intClass;
+      } else {
+        tmp_0 = PrimitiveClasses_getInstance().doubleClass;
+      }
+
+      tmp = tmp_0;
+      break;
+    case 'boolean':
+      tmp = PrimitiveClasses_getInstance().booleanClass;
+      break;
+    case 'function':
+      var tmp_1 = PrimitiveClasses_getInstance();
+      // Inline function 'kotlin.js.asDynamic' call
+
+      tmp = tmp_1.functionClass(e.length);
+      break;
+    default:
+      var tmp_2;
+      if (isBooleanArray(e)) {
+        tmp_2 = PrimitiveClasses_getInstance().booleanArrayClass;
+      } else {
+        if (isCharArray(e)) {
+          tmp_2 = PrimitiveClasses_getInstance().charArrayClass;
+        } else {
+          if (isByteArray(e)) {
+            tmp_2 = PrimitiveClasses_getInstance().byteArrayClass;
+          } else {
+            if (isShortArray(e)) {
+              tmp_2 = PrimitiveClasses_getInstance().shortArrayClass;
+            } else {
+              if (isIntArray(e)) {
+                tmp_2 = PrimitiveClasses_getInstance().intArrayClass;
+              } else {
+                if (isLongArray(e)) {
+                  tmp_2 = PrimitiveClasses_getInstance().longArrayClass;
+                } else {
+                  if (isFloatArray(e)) {
+                    tmp_2 = PrimitiveClasses_getInstance().floatArrayClass;
+                  } else {
+                    if (isDoubleArray(e)) {
+                      tmp_2 = PrimitiveClasses_getInstance().doubleArrayClass;
+                    } else {
+                      if (isInterface(e, KClass())) {
+                        tmp_2 = getKClass(KClass());
+                      } else {
+                        if (isArray(e)) {
+                          tmp_2 = PrimitiveClasses_getInstance().arrayClass;
+                        } else {
+                          var constructor = Object.getPrototypeOf(e).constructor;
+                          var tmp_3;
+                          if (constructor === Object) {
+                            tmp_3 = PrimitiveClasses_getInstance().anyClass;
+                          } else if (constructor === Error) {
+                            tmp_3 = PrimitiveClasses_getInstance().throwableClass;
+                          } else {
+                            var jsClass = constructor;
+                            tmp_3 = getKClass(jsClass);
+                          }
+                          tmp_2 = tmp_3;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      tmp = tmp_2;
+      break;
+  }
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return tmp;
+}
+//region block: exports
+export {
+  getKClassFromExpression as getKClassFromExpression348iqjl4fnx2f,
+  getKClass as getKClass3t8tygqu4lcxf,
+};
+//endregion
+
+//# sourceMappingURL=reflection.mjs.map

package/kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["js/src/kotlin/reflect/reflection.kt","js/runtime/runtimeForStdLib.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["getKClass","jClass","metadata","kClass","getKClassFromExpression","e","constructor","jsClass"],"mappings":";;;;;;;;;;;;;;;;;;;kBAQSA,CAAwBC,MAAxBD,EAAuD;A,EACxD,eAAW,MAAX,C;;;IAAyB,sCAAwB,W;;;MAErDE,WAAe,MAAfA,CAAkC,U;;EAEvB,gBAAY,IAAZ,C;;IACH,aAAS,QAAT,IAAuB,IAAvB,C;UACAC,kCAA8B,MAA9BA,C;MACA,oBAAsB,M;cACtB,M;;cAEA,Q,CAAS,Q;;UANY,K;;mCASR,M;;EATrB,U;AAWJ,C;gCAGSC,CAAsCC,CAAtCD,EACL;A;EAAA,QAAM,OAAS,CAAf,C;SACI,Q;2CAA6B,W;;SAC7B,Q;;;;;;MAAgB,KAAY,CCjByB,GDiBtB,CAAf,MAAkC,CAAlC,C;+CAAsD,Q;;+CAA+B,W;;;;;SACrG,S;2CAA8B,Y;;SAC9B,U;;;;YAA+B,oBAAc,CAAd,CAA4B,MAA5B,C;;;;MAGvB,sB;+CAAsC,iB;;QACtC,mB;iDAAmC,c;;UACnC,mB;mDAAmC,c;;YACnC,oB;qDAAoC,e;;cACpC,kB;uDAAkC,a;;gBAClC,mB;yDAAmC,c;;kBACnC,oB;2DAAoC,e;;oBACpC,qB;6DAAqC,gB;;sBACrC,6B;;;wBACA,e;iEAAkC,U;;8BAE9BE,cAAkB,MAAa,gBAAe,CAAf,CAA/BA,CAAiD,W;;0BAE7C,oBAAgB,MAAhB,C;mEAAiD,Q;iCACjD,oBAAgB,KAAhB,C;mEAAgD,c;;gCAE5CC,UAA0B,W;oCAC1B,UAAU,OAAV,C;;;;;;;;;;;;;;;;;;;EAMC,OA9BzB,G;AA8BwB,C;;;;;"}

package/kotlin-kotlin-stdlib/kotlin/sequences/SequenceBuilder.mjs

@@ -0,0 +1,169 @@
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../js/void.mjs';
+import { createCoroutineUninterceptedGeneratorVersion2gduom218i9ay as createCoroutineUninterceptedGeneratorVersion } from '../coroutines/intrinsics/IntrinsicsJs.mjs';
+import {
+  NoSuchElementException679xzhnp5bpj as NoSuchElementException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+} from '../exceptions.mjs';
+import {
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../hacks.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../Unit.mjs';
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+  throwOnFailure24snjmtlqgzo8 as throwOnFailure,
+  _Result___get_value__impl__bjfvqg2ei4op8d4d2m as _Result___get_value__impl__bjfvqg,
+} from '../Result.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../coroutines/intrinsics/Intrinsics.mjs';
+import { EmptyCoroutineContext_instance2qpebg1xogbvt as EmptyCoroutineContext_instance } from '../coroutines/CoroutineContextImpl.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from '../coroutines/Continuation.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function sequence(block) {
+  // Inline function 'kotlin.sequences.Sequence' call
+  return new (sequence$$inlined$Sequence$1())(block);
+}
+var SequenceScopeClass;
+function SequenceScope() {
+  if (SequenceScopeClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'SequenceScope', VOID, VOID, VOID, [1]);
+    SequenceScopeClass = $;
+  }
+  return SequenceScopeClass;
+}
+function iterator(block) {
+  var iterator = new (SequenceBuilderIterator())();
+  iterator.hk_1 = createCoroutineUninterceptedGeneratorVersion(block, iterator, iterator);
+  return iterator;
+}
+function nextNotReady($this) {
+  if (!$this.l1())
+    throw NoSuchElementException().i6();
+  else
+    return $this.m1();
+}
+function exceptionalState($this) {
+  switch ($this.ek_1) {
+    case 4:
+      return NoSuchElementException().i6();
+    case 5:
+      return IllegalStateException().w4('Iterator has failed.');
+    default:
+      return IllegalStateException().w4('Unexpected state of the iterator: ' + $this.ek_1);
+  }
+}
+var SequenceBuilderIteratorClass;
+function SequenceBuilderIterator() {
+  if (SequenceBuilderIteratorClass === VOID) {
+    class $ extends SequenceScope() {
+      constructor() {
+        super();
+        this.ek_1 = 0;
+        this.fk_1 = null;
+        this.gk_1 = null;
+        this.hk_1 = null;
+      }
+      l1() {
+        while (true) {
+          switch (this.ek_1) {
+            case 0:
+              break;
+            case 1:
+              if (ensureNotNull(this.gk_1).l1()) {
+                this.ek_1 = 2;
+                return true;
+              } else {
+                this.gk_1 = null;
+              }
+
+              break;
+            case 4:
+              return false;
+            case 3:
+            case 2:
+              return true;
+            default:
+              throw exceptionalState(this);
+          }
+          this.ek_1 = 5;
+          var step = ensureNotNull(this.hk_1);
+          this.hk_1 = null;
+          // Inline function 'kotlin.coroutines.resume' call
+          // Inline function 'kotlin.Companion.success' call
+          var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+          step.vb(tmp$ret$0);
+        }
+      }
+      m1() {
+        switch (this.ek_1) {
+          case 0:
+          case 1:
+            return nextNotReady(this);
+          case 2:
+            this.ek_1 = 1;
+            return ensureNotNull(this.gk_1).m1();
+          case 3:
+            this.ek_1 = 0;
+            var tmp = this.fk_1;
+            var result = (tmp == null ? true : !(tmp == null)) ? tmp : THROW_CCE();
+            this.fk_1 = null;
+            return result;
+          default:
+            throw exceptionalState(this);
+        }
+      }
+      dk(value, $completion) {
+        this.fk_1 = value;
+        this.ek_1 = 3;
+        this.hk_1 = $completion;
+        return get_COROUTINE_SUSPENDED();
+      }
+      ik(result) {
+        // Inline function 'kotlin.getOrThrow' call
+        throwOnFailure(result);
+        var tmp = _Result___get_value__impl__bjfvqg(result);
+        if (!(tmp == null ? true : !(tmp == null)))
+          THROW_CCE();
+        this.ek_1 = 4;
+      }
+      vb(result) {
+        return this.ik(result);
+      }
+      tb() {
+        return EmptyCoroutineContext_instance;
+      }
+    }
+    initMetadataForClass($, 'SequenceBuilderIterator', SequenceBuilderIterator, VOID, [SequenceScope(), Continuation()], [1]);
+    SequenceBuilderIteratorClass = $;
+  }
+  return SequenceBuilderIteratorClass;
+}
+var sequence$$inlined$Sequence$1Class;
+function sequence$$inlined$Sequence$1() {
+  if (sequence$$inlined$Sequence$1Class === VOID) {
+    class $ {
+      constructor($block) {
+        this.jk_1 = $block;
+      }
+      k1() {
+        return iterator(this.jk_1);
+      }
+    }
+    initMetadataForClass($);
+    sequence$$inlined$Sequence$1Class = $;
+  }
+  return sequence$$inlined$Sequence$1Class;
+}
+//region block: exports
+export {
+  SequenceScope as SequenceScope1coiso86pqzq2,
+  sequence as sequence2vgswtrxvqoa7,
+};
+//endregion
+
+//# sourceMappingURL=SequenceBuilder.mjs.map

package/kotlin-kotlin-stdlib/kotlin/sequences/SequenceBuilder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/collections/SequenceBuilder.kt","src/kotlin/collections/Sequences.kt","src/kotlin/util/Result.kt","src/kotlin/coroutines/Continuation.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["sequence","block","iterator","nextNotReady","exceptionalState","hasNext","step","next","result","yield","value","$completion","resumeWith","<get-context>","$block"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;iBAyBOA,CAAiBC,KAAjBD,EAA8F;A;EAA4B,OCJ1C,2C;ADIyC,C;;;;;;;;;;iBAUzHE,CAAiBD,KAAjBC,EAA4F;A,MAC/FA,4C;EACA,QAAS,QAAiB,6CAAN,KAAM,EAAwC,QAAxC,EAA+D,QAA/D,C;EAC1B,OAAO,Q;AACX,C;qBA+GYC,CAAA,KAAAA,EAAsB;A,EACtB,KAAC,UAAD,C;IAAY,mC;;IAAoC,OAAO,U;AAC/D,C;yBAEQC,CAAA,KAAAA,EAAoC;A,EAI3C,QAJiD,KAIjD,CAJiD,IAIjD,C;SAHG,C;;SACA,C;wCAAsC,sB;;wCACP,oC,GAAmC,K,CAAA,I;;AACtE,C;;;;;;;QAtDoB,a;QACQ,gB;QACa,gB;QACL,gB;;QAE3BC,CAAAA,EAAuB;A,eACrB,I,EAAM;A,UACT,QAAM,IAAN,CAAM,IAAN,C;iBACI,C;;iBACA,C;cACQ,IAAA,wBAAe,KAAf,C,CAA0B;A,gBAC1B,YAAQ,C;gBACR,OAAO,I;cACX,C,MAAO;A,gBACH,YAAe,I;cACnB,C;;;iBACJ,C;cAAc,OAAO,K;iBACrB,C;iBAAa,C;cAAmB,OAAO,I;;cAC/B,MAAM,sB;;UAGlB,YAAQ,C;cACRC,OAAW,wB;UACX,YAAW,I;;;cEnCE,YAAb,2C;UFoCA,IGpFR,IAAkB,SAAlB,C;QHqFI,C;MACJ,C;QAESC,CAAAA,EAAc;A,QACnB,QAAM,IAAN,CAAM,IAAN,C;eACI,C;eAAgB,C;YAAsB,OAAO,kB;eAC7C,C;YACI,YAAQ,C;YACR,OAAO,wBAAe,K;eAE1B,C;YACI,YAAQ,C;sBAEK,I,CAAA,I;gBAAbC,iDAAa,GAAbA,c;YACA,YAAY,I;YACZ,OAAO,M;;YAEH,MAAM,sB;;MAEtB,C;QAaiBC,CAAUC,K,EAAVC,WAAAF,EAAoB;A,QACjC,YAAY,K;QACZ,YAAQ,C;QAEJ,YAnIQ,W;QAsIhB,OAFQ,yB;MAER,C;QAaSG,CAAeJ,MAAfI,EAAqC;A;QER9C,eFSI,METJ,C;kBACO,kCFQH,MERG,C;;;QFSH,YAAQ,C;MACZ,C;SA/JiDJ,M;;;QAkK7CK,CAAAA,EAAQ;A,QAAqB,qC;MAAD,C;;;;;;;;;;;kBCrKjCC,M;;;QAAUZ,CAAAA,EAA8B;A,QAAU,ODG2D,SAAS,IAAT,CAAS,IAAT,C;MCH5D,C;;;;;;;;;;;"}