@solibo/solibo-sdk 1.0.23-SNAPSHOT

package/KmLogging-logging.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['KmLogging-logging'] = factory(typeof globalThis['KmLogging-logging'] === 'undefined' ? {} : globalThis['KmLogging-logging']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=KmLogging-logging.js.map

package/KmLogging-logging.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/Kotlin-DateTime-library-kotlinx-datetime.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['Kotlin-DateTime-library-kotlinx-datetime'] = factory(typeof globalThis['Kotlin-DateTime-library-kotlinx-datetime'] === 'undefined' ? {} : globalThis['Kotlin-DateTime-library-kotlinx-datetime']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=Kotlin-DateTime-library-kotlinx-datetime.js.map

package/Kotlin-DateTime-library-kotlinx-datetime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/KotlinBigInteger-bignum.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['KotlinBigInteger-bignum'] = factory(typeof globalThis['KotlinBigInteger-bignum'] === 'undefined' ? {} : globalThis['KotlinBigInteger-bignum']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=KotlinBigInteger-bignum.js.map

package/KotlinBigInteger-bignum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/MultiplatformSettings-multiplatform-settings-no-arg.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['MultiplatformSettings-multiplatform-settings-no-arg'] = factory(typeof globalThis['MultiplatformSettings-multiplatform-settings-no-arg'] === 'undefined' ? {} : globalThis['MultiplatformSettings-multiplatform-settings-no-arg']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=MultiplatformSettings-multiplatform-settings-no-arg.js.map

package/MultiplatformSettings-multiplatform-settings-no-arg.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/MultiplatformSettings-multiplatform-settings.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['MultiplatformSettings-multiplatform-settings'] = factory(typeof globalThis['MultiplatformSettings-multiplatform-settings'] === 'undefined' ? {} : globalThis['MultiplatformSettings-multiplatform-settings']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=MultiplatformSettings-multiplatform-settings.js.map

package/MultiplatformSettings-multiplatform-settings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/Stately-stately-concurrency.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['Stately-stately-concurrency'] = factory(typeof globalThis['Stately-stately-concurrency'] === 'undefined' ? {} : globalThis['Stately-stately-concurrency']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=Stately-stately-concurrency.js.map

package/Stately-stately-concurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/Stately-stately-strict.js

@@ -0,0 +1,19 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['Stately-stately-strict'] = factory(typeof globalThis['Stately-stately-strict'] === 'undefined' ? {} : globalThis['Stately-stately-strict']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  var strictMemoryModel;
+  //region block: init
+  strictMemoryModel = false;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=Stately-stately-strict.js.map

package/Stately-stately-strict.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../Stately/Stately/stately-strict/src/jsAndWasmJsMain/kotlin/co/touchlab/stately/strict/HelpersJS.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;sBAmBwC,K;;;;"}

package/cryptography-kotlin-cryptography-bigint.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['cryptography-kotlin-cryptography-bigint'] = factory(typeof globalThis['cryptography-kotlin-cryptography-bigint'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-bigint']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-bigint.js.map

package/cryptography-kotlin-cryptography-bigint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/cryptography-kotlin-cryptography-core.js

@@ -0,0 +1,213 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './cryptography-kotlin-cryptography-random.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./cryptography-kotlin-cryptography-random.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'cryptography-kotlin-cryptography-core'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'cryptography-kotlin-cryptography-core'.");
+    }
+    if (typeof globalThis['cryptography-kotlin-cryptography-random'] === 'undefined') {
+      throw new Error("Error loading module 'cryptography-kotlin-cryptography-core'. Its dependency 'cryptography-kotlin-cryptography-random' was not found. Please, check whether 'cryptography-kotlin-cryptography-random' is loaded prior to 'cryptography-kotlin-cryptography-core'.");
+    }
+    globalThis['cryptography-kotlin-cryptography-core'] = factory(typeof globalThis['cryptography-kotlin-cryptography-core'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-core'], globalThis['kotlin-kotlin-stdlib'], globalThis['cryptography-kotlin-cryptography-random']);
+  }
+}(function (_, kotlin_kotlin, kotlin_dev_whyoleg_cryptography_cryptography_random) {
+  'use strict';
+  //region block: imports
+  var protoOf = kotlin_kotlin.$_$.t;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.q;
+  var initMetadataForClass = kotlin_kotlin.$_$.p;
+  var Unit_instance = kotlin_kotlin.$_$.f;
+  var initMetadataForObject = kotlin_kotlin.$_$.r;
+  var VOID = kotlin_kotlin.$_$.a;
+  var equals = kotlin_kotlin.$_$.n;
+  var FunctionAdapter = kotlin_kotlin.$_$.l;
+  var isInterface = kotlin_kotlin.$_$.s;
+  var Comparator = kotlin_kotlin.$_$.w;
+  var hashCode = kotlin_kotlin.$_$.o;
+  var compareValues = kotlin_kotlin.$_$.k;
+  var sortedWith = kotlin_kotlin.$_$.j;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.h;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.b;
+  var toString = kotlin_kotlin.$_$.u;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.e;
+  var first = kotlin_kotlin.$_$.i;
+  var Default_getInstance = kotlin_dev_whyoleg_cryptography_cryptography_random.$_$.a;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.c;
+  var lazy = kotlin_kotlin.$_$.z;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.d;
+  var THROW_CCE = kotlin_kotlin.$_$.x;
+  var KtMap = kotlin_kotlin.$_$.g;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(CryptographyProvider, 'CryptographyProvider');
+  initMetadataForObject(CryptographySystem, 'CryptographySystem');
+  initMetadataForClass(CompositeProvider, 'CompositeProvider', VOID, CryptographyProvider);
+  initMetadataForClass(sam$kotlin_Comparator$0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+  initMetadataForClass(CryptographySystemImpl, 'CryptographySystemImpl', CryptographySystemImpl);
+  //endregion
+  function Companion() {
+  }
+  var Companion_instance;
+  function Companion_getInstance() {
+    return Companion_instance;
+  }
+  function CryptographyProvider() {
+  }
+  function CryptographySystem() {
+    CryptographySystem_instance = this;
+    this.d5_1 = new CryptographySystemImpl();
+    loadProviders(this);
+  }
+  protoOf(CryptographySystem).e5 = function (provider, priority) {
+    return this.d5_1.e5(provider, priority);
+  };
+  var CryptographySystem_instance;
+  function CryptographySystem_getInstance() {
+    if (CryptographySystem_instance == null)
+      new CryptographySystem();
+    return CryptographySystem_instance;
+  }
+  function CompositeProvider(providers) {
+    CryptographyProvider.call(this);
+    this.l5_1 = providers;
+  }
+  function sam$kotlin_Comparator$0(function_0) {
+    this.m5_1 = function_0;
+  }
+  protoOf(sam$kotlin_Comparator$0).n5 = function (a, b) {
+    return this.m5_1(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0).compare = function (a, b) {
+    return this.n5(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0).x = function () {
+    return this.m5_1;
+  };
+  protoOf(sam$kotlin_Comparator$0).equals = function (other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, Comparator) : false) {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+        tmp_0 = equals(this.x(), other.x());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(sam$kotlin_Comparator$0).hashCode = function () {
+    return hashCode(this.x());
+  };
+  function CryptographySystemImpl$lazyRegisteredProviders$lambda$lambda(a, b) {
+    // Inline function 'kotlin.comparisons.compareValuesBy' call
+    var tmp = a.l();
+    var tmp$ret$1 = b.l();
+    return compareValues(tmp, tmp$ret$1);
+  }
+  function CryptographySystemImpl$lazyRegisteredProviders$lambda(this$0) {
+    return function () {
+      // Inline function 'kotlin.collections.sortedBy' call
+      var this_0 = this$0.f5_1.p();
+      // Inline function 'kotlin.comparisons.compareBy' call
+      var tmp = CryptographySystemImpl$lazyRegisteredProviders$lambda$lambda;
+      var tmp$ret$0 = new sam$kotlin_Comparator$0(tmp);
+      // Inline function 'kotlin.collections.map' call
+      var this_1 = sortedWith(this_0, tmp$ret$0);
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+      var _iterator__ex2g4s = this_1.c();
+      while (_iterator__ex2g4s.d()) {
+        var item = _iterator__ex2g4s.e();
+        var tmp$ret$2 = item.m().m();
+        destination.i(tmp$ret$2);
+      }
+      return destination;
+    };
+  }
+  function CryptographySystemImpl$lazyDefaultProvider$lambda(this$0) {
+    return function () {
+      var tmp0_elvis_lhs = this$0.h5_1;
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        // Inline function 'kotlin.let' call
+        var it = this$0.g5_1.m();
+        var tmp_0;
+        switch (it.f()) {
+          case 0:
+            var message = 'No providers registered. Please provide a dependency or register provider explicitly';
+            throw IllegalStateException_init_$Create$(toString(message));
+          case 1:
+            tmp_0 = first(it);
+            break;
+          default:
+            tmp_0 = new CompositeProvider(it);
+            break;
+        }
+        tmp = tmp_0;
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      return tmp;
+    };
+  }
+  function CryptographySystemImpl$lazyDefaultRandom$lambda(this$0) {
+    return function () {
+      var tmp0_elvis_lhs = this$0.j5_1;
+      return tmp0_elvis_lhs == null ? Default_getInstance() : tmp0_elvis_lhs;
+    };
+  }
+  function CryptographySystemImpl() {
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    tmp.f5_1 = LinkedHashMap_init_$Create$();
+    var tmp_0 = this;
+    tmp_0.g5_1 = lazy(CryptographySystemImpl$lazyRegisteredProviders$lambda(this));
+    this.h5_1 = null;
+    var tmp_1 = this;
+    tmp_1.i5_1 = lazy(CryptographySystemImpl$lazyDefaultProvider$lambda(this));
+    this.j5_1 = null;
+    var tmp_2 = this;
+    tmp_2.k5_1 = lazy(CryptographySystemImpl$lazyDefaultRandom$lambda(this));
+  }
+  protoOf(CryptographySystemImpl).e5 = function (provider, priority) {
+    // Inline function 'kotlin.require' call
+    if (!(priority >= 0)) {
+      var message = 'Priority must be greater or equal to 0';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.collections.contains' call
+    // Inline function 'kotlin.collections.containsKey' call
+    var this_0 = this.f5_1;
+    // Inline function 'kotlin.require' call
+    if (!!(isInterface(this_0, KtMap) ? this_0 : THROW_CCE()).n(priority)) {
+      var message_0 = 'Provider with priority ' + priority + ' already registered. Every registered provider should have unique priority.';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    // Inline function 'kotlin.check' call
+    if (!!this.g5_1.s4()) {
+      var message_1 = 'Cannot register provider after `getRegisteredProviders` was called';
+      throw IllegalStateException_init_$Create$(toString(message_1));
+    }
+    // Inline function 'kotlin.collections.set' call
+    this.f5_1.n1(priority, provider);
+  };
+  function loadProviders(_this__u8e3s4) {
+  }
+  //region block: init
+  Companion_instance = new Companion();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = CryptographyProvider;
+  _.$_$.b = CryptographySystem_getInstance;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-core.js.map

package/cryptography-kotlin-cryptography-core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-core/src/commonMain/kotlin/CryptographyProvider.kt","../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-core/src/commonMain/kotlin/CryptographySystem.kt","src/kotlin/comparisons/Comparisons.kt","common/src/generated/_Collections.kt","src/kotlin/collections/Maps.kt","src/kotlin/util/Preconditions.kt","../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-core/src/nonJvmMain/kotlin/CryptographySystem.nonJvm.kt"],"sourcesContent":[null,null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<init>","registerProvider","provider","priority","providers","compare","a","b","equals","hashCode","CryptographySystemImpl$lazyRegisteredProviders$lambda$lambda","CryptographySystemImpl$lazyRegisteredProviders$lambda","item","CryptographySystemImpl$lazyDefaultProvider$lambda","CryptographySystemImpl$lazyDefaultProvider$lambda$lambda","CryptographySystemImpl$lazyDefaultRandom$lambda","CryptographySystemImpl$lazyDefaultRandom$lambda$lambda","message","loadProviders","<this>"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwDIA,CAAAA,EAAA;A,EAAA,C;;;;;+BAlDJA,CAAAA,EAAA;A,EAAA,C;6BCGAA,CAAAA,EAAA;A;IACuB,wC;IAGf,mB;EAJR,C;4CAYIC,CAA4BC,Q,EAAsCC,QAAlEF,EAAyF;A,IAAyC,OAAzC,IAAK,CAAL,IAAK,IAAiB,QAAjB,EAA2B,QAA3B,C;EAAmC,C;;;;;;;4BAmElGD,CAC3BI,SAD2BJ,EAAA;A,IAE3B,+B;IADA,qB;EAD2B,C;kCAUTA,C,UAAAA,EAAA;A,IAAA,sB;EAAA,C;iDAAAK,CAtFvBC,C,EAAMC,CAsFiBF,E;;G;uDAtFvBC,C,EAAMC,C;;;;;;qDAZTC,C,KAAAA,E;;;;;;;;;;;;;;G;uDAAAC,CAAAA,E;;G;uEAkGqCC,CAAE,C,EAAG,CAALA,EAAA;A;cAA0B,CAjEb,I;QAAG,YAiEa,CAjEhB,I;IAiE4B,OCzDnE,mBAA2B,SAA3B,C;ED0DX,C;gEAnE+CC,CAH/C,MAG+CA,E;oBAAAD,CAAAA,EAAA;A;mBACvC,MAAoB,CAApB,IAAoB,I;;UCoEb,kE;UAA2C,YAAtD,4BAAW,GAAX,C;;mBCs8BO,mBAAW,SAAX,C;;wBAsgBM,wBAAa,gCAAwB,EAAxB,CAAb,C;UA2EA,oBA3EN,MA2EM,I;aAAA,qB,EACT;A,YADCE,OAAQ,qB;YF3lD2D,YE4lD1C,IF5lD+B,IAAM,I;QE4lD/D,WAAY,GAAI,SAAJ,C;MAAmB,C;MF5lDuC,OE6lDnE,W;IF5lDP,C;G;4DAGuCC,CAR3C,MAQ2CA,E;oBAAAC,CAAAA,EAAA;A,UACnC,4B;;MAAA,2B;;iBAAmB,MAAwB,CAAxB,IAAwB,I;;QACvC,QAAM,EAAG,IAAT,C;eACI,C;0BAAc,sF;YA0DqB,MAAM,oCACjD,SAAR,OAAQ,CADiD,C;eAzDzC,C;oBAAW,MAAH,EAAG,C;;;oBACH,sBAAkB,EAAlB,C;;;cAHZ,K;;cADJ,c;;MAMC,U;IACL,C;G;0DAGqCC,CAnBzC,MAmByCA,E;oBAAAC,CAAAA,EAAA;A,UACjC,4B;MAA2C,OAA3C,+D;IACJ,C;G;iCArBJhB,CAAAA,EAAA;A,cAEsC,I;;IAAA,WGqDsB,6B;gBHpDlB,I;IAAA,kBAAK,2DAAL,C;IAIe,gB;gBACnB,I;IAAA,kBAAK,uDAAL,C;IAUe,gB;gBACjB,I;IAAA,kBAAK,qDAAL,C;EAnBpC,C;gDAoCIC,CAAqBC,Q,EAAsCC,QAA3DF,EAA0E;A;II9BtE,MJ+BQ,YAAY,CI/BpB,E,CAAQ;A,UACRgB,UJ8ByB,wC;MI7BzB,MAAM,uCAAiC,SAAR,OAAQ,CAAjC,C;IACV,C;;;iBJ6ByB,I,CAAA,I;;IIhCrB,KJgCQ,CG+MoC,aAAnB,MAAmB,WAAnB,MAAmB,kBH/MpC,QG+MoC,CC/O5C,C,CAAQ;A,UACRA,YJgCK,yBAAD,GAAyB,QAAzB,GAAiC,6E;MI/BrC,MAAM,uCAAiC,SAAR,SAAQ,CAAjC,C;IACV,C;;IA6DI,KJ5BM,CAAC,IAAwB,CAAxB,IAAwB,KI4B/B,C,CAAQ;A,UACRA,YJ5BI,oE;MI6BJ,MAAM,oCAA8B,SAAR,SAAQ,CAA9B,C;IACV,C;;IJ3BI,IG6LJ,CH7LI,IG6LJ,IH7LwB,QG6LxB,EH7LoC,QG6LpC,C;EH5LA,C;wBKtEJC,CAAoBC,aAApBD,EAAuD;A,EAAC,C;;;;;;;;;;;"}

package/cryptography-kotlin-cryptography-provider-base.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['cryptography-kotlin-cryptography-provider-base'] = factory(typeof globalThis['cryptography-kotlin-cryptography-provider-base'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-provider-base']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-provider-base.js.map

package/cryptography-kotlin-cryptography-provider-base.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/cryptography-kotlin-cryptography-provider-optimal.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['cryptography-kotlin-cryptography-provider-optimal'] = factory(typeof globalThis['cryptography-kotlin-cryptography-provider-optimal'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-provider-optimal']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-provider-optimal.js.map

package/cryptography-kotlin-cryptography-provider-optimal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/cryptography-kotlin-cryptography-provider-webcrypto.js

@@ -0,0 +1,84 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './cryptography-kotlin-cryptography-core.js', './kotlin-kotlin-stdlib.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./cryptography-kotlin-cryptography-core.js'), require('./kotlin-kotlin-stdlib.js'));
+  else {
+    if (typeof globalThis['cryptography-kotlin-cryptography-core'] === 'undefined') {
+      throw new Error("Error loading module 'cryptography-kotlin-cryptography-provider-webcrypto'. Its dependency 'cryptography-kotlin-cryptography-core' was not found. Please, check whether 'cryptography-kotlin-cryptography-core' is loaded prior to 'cryptography-kotlin-cryptography-provider-webcrypto'.");
+    }
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'cryptography-kotlin-cryptography-provider-webcrypto'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'cryptography-kotlin-cryptography-provider-webcrypto'.");
+    }
+    globalThis['cryptography-kotlin-cryptography-provider-webcrypto'] = factory(typeof globalThis['cryptography-kotlin-cryptography-provider-webcrypto'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-provider-webcrypto'], globalThis['cryptography-kotlin-cryptography-core'], globalThis['kotlin-kotlin-stdlib']);
+  }
+}(function (_, kotlin_dev_whyoleg_cryptography_cryptography_core, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var CryptographyProvider = kotlin_dev_whyoleg_cryptography_cryptography_core.$_$.a;
+  var protoOf = kotlin_kotlin.$_$.t;
+  var initMetadataForObject = kotlin_kotlin.$_$.r;
+  var VOID = kotlin_kotlin.$_$.a;
+  var lazy = kotlin_kotlin.$_$.z;
+  var CryptographySystem_getInstance = kotlin_dev_whyoleg_cryptography_cryptography_core.$_$.b;
+  var Unit_instance = kotlin_kotlin.$_$.f;
+  var defineProp = kotlin_kotlin.$_$.m;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForObject(WebCryptoCryptographyProvider, 'WebCryptoCryptographyProvider', VOID, CryptographyProvider);
+  //endregion
+  function get_defaultProvider() {
+    _init_properties_WebCryptoCryptographyProvider_kt__i22tls();
+    return defaultProvider;
+  }
+  var defaultProvider;
+  var WebCrypto$delegate;
+  function WebCryptoCryptographyProvider() {
+    WebCryptoCryptographyProvider_instance = this;
+    CryptographyProvider.call(this);
+  }
+  var WebCryptoCryptographyProvider_instance;
+  function WebCryptoCryptographyProvider_getInstance() {
+    if (WebCryptoCryptographyProvider_instance == null)
+      new WebCryptoCryptographyProvider();
+    return WebCryptoCryptographyProvider_instance;
+  }
+  function defaultProvider$lambda() {
+    _init_properties_WebCryptoCryptographyProvider_kt__i22tls();
+    return WebCryptoCryptographyProvider_getInstance();
+  }
+  var properties_initialized_WebCryptoCryptographyProvider_kt_n89q9u;
+  function _init_properties_WebCryptoCryptographyProvider_kt__i22tls() {
+    if (!properties_initialized_WebCryptoCryptographyProvider_kt_n89q9u) {
+      properties_initialized_WebCryptoCryptographyProvider_kt_n89q9u = true;
+      defaultProvider = lazy(defaultProvider$lambda);
+      WebCrypto$delegate = get_defaultProvider();
+    }
+  }
+  function get_initHook() {
+    return initHook;
+  }
+  var initHook;
+  function initHook$init$() {
+    CryptographySystem_getInstance().e5(get_defaultProvider(), 100);
+    return Unit_instance;
+  }
+  //region block: eager init
+  initHook = initHook$init$();
+  //endregion
+  //region block: exports
+  function $jsExportAll$(_) {
+    var $dev = _.dev || (_.dev = {});
+    var $dev$whyoleg = $dev.whyoleg || ($dev.whyoleg = {});
+    var $dev$whyoleg$cryptography = $dev$whyoleg.cryptography || ($dev$whyoleg.cryptography = {});
+    var $dev$whyoleg$cryptography$providers = $dev$whyoleg$cryptography.providers || ($dev$whyoleg$cryptography.providers = {});
+    var $dev$whyoleg$cryptography$providers$webcrypto = $dev$whyoleg$cryptography$providers.webcrypto || ($dev$whyoleg$cryptography$providers.webcrypto = {});
+    defineProp($dev$whyoleg$cryptography$providers$webcrypto, 'initHook', get_initHook, VOID, true);
+  }
+  $jsExportAll$(_);
+  _.$jsExportAll$ = $jsExportAll$;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-provider-webcrypto.js.map

package/cryptography-kotlin-cryptography-provider-webcrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-providers/webcrypto/src/commonMain/kotlin/WebCryptoCryptographyProvider.kt","../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-providers/webcrypto/src/jsMain/kotlin/WebCryptoCryptographyProvider.js.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-defaultProvider>","<init>","defaultProvider$lambda","<init properties WebCryptoCryptographyProvider.kt>","<get-initHook>"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAUAA,CAAAA,EAAA;A;IAAA,sB;EAA2B,C;;;wCAI3BC,CAAAA,EAAA;A;IAAgD,+B;EAAhD,C;;;;;;;iCAJoCC,CAAAA,EAAA;A;IAA+B,kD;EAAC,C;;oEAVpEC,CAAAA,E;;;wBAU+B,KAAK,sBAAL,C;2BAE8C,qB;;G;uBCF7EC,CAAAA,EAAA;A,IAAA,e;EAK2B,C;;4BAAuB;A,IAAA,oCAAiB,qBAAjB,EAAkC,GAAlC,C;;EAAqC,C;;;;;;;;;;;;;;;;;;"}

package/cryptography-kotlin-cryptography-random.js

@@ -0,0 +1,70 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'cryptography-kotlin-cryptography-random'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'cryptography-kotlin-cryptography-random'.");
+    }
+    globalThis['cryptography-kotlin-cryptography-random'] = factory(typeof globalThis['cryptography-kotlin-cryptography-random'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-random'], globalThis['kotlin-kotlin-stdlib']);
+  }
+}(function (_, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var protoOf = kotlin_kotlin.$_$.t;
+  var initMetadataForClass = kotlin_kotlin.$_$.p;
+  var VOID = kotlin_kotlin.$_$.a;
+  var initMetadataForObject = kotlin_kotlin.$_$.r;
+  var Random = kotlin_kotlin.$_$.v;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForClass(CryptographyRandom, 'CryptographyRandom', VOID, Random);
+  initMetadataForClass(AbstractRandom, 'AbstractRandom', VOID, CryptographyRandom);
+  initMetadataForObject(Default, 'Default', VOID, CryptographyRandom);
+  initMetadataForObject(WebCryptoCryptographyRandom, 'WebCryptoCryptographyRandom', VOID, AbstractRandom);
+  //endregion
+  function AbstractRandom() {
+    CryptographyRandom.call(this);
+  }
+  function Default() {
+    Default_instance = this;
+    CryptographyRandom.call(this);
+    this.a5_1 = defaultCryptographyRandom();
+  }
+  var Default_instance;
+  function Default_getInstance() {
+    if (Default_instance == null)
+      new Default();
+    return Default_instance;
+  }
+  function CryptographyRandom() {
+    Default_getInstance();
+    Random.call(this);
+  }
+  function defaultCryptographyRandom() {
+    return WebCryptoCryptographyRandom_getInstance();
+  }
+  function WebCryptoCryptographyRandom() {
+    WebCryptoCryptographyRandom_instance = this;
+    AbstractRandom.call(this);
+    this.b5_1 = 65536;
+    this.c5_1 = getCrypto();
+  }
+  var WebCryptoCryptographyRandom_instance;
+  function WebCryptoCryptographyRandom_getInstance() {
+    if (WebCryptoCryptographyRandom_instance == null)
+      new WebCryptoCryptographyRandom();
+    return WebCryptoCryptographyRandom_instance;
+  }
+  function getCrypto() {
+    return globalThis ? globalThis.crypto : window.crypto || window.msCrypto;
+  }
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Default_getInstance;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-random.js.map

package/cryptography-kotlin-cryptography-random.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-random/src/commonMain/kotlin/AbstractRandom.kt","../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-random/src/commonMain/kotlin/CryptographyRandom.kt","../../../../../../../../../cryptography-kotlin/cryptography-kotlin/cryptography-random/src/jsMain/kotlin/CryptographyRandom.js.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<init>","defaultCryptographyRandom","getCrypto"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;yBAMAA,CAAAA,EAAA;A,IAAyC,6B;EAAzC,C;kBCGIA,CAAAA,EAAA;A;IAAkC,6B;IACkB,uC;EADpD,C;;;;;;;6BADJA,CAAAA,EAAA;A,IAAA,qB;IAA2C,iB;EAA3C,C;oCCAAC,CAAAA,EAAsE;A,IAA2B,gD;EAAD,C;sCAEhGD,CAAAA,EAAA;A;IAA6C,yB;IACN,iB;IACN,uB;EAFjC,C;;;;;;;oBA2BAE,CAAAA,EAAkC;A,IAA2E,OAAvE,UAAJ,GAAiB,UAAjB,CAA4B,MAA5B,GAAsC,MAAc,CAAP,MAAO,IAAG,MAAH,CAAU,Q;EAAY,C;;;;;;;"}

package/cryptography-kotlin-cryptography-serialization-asn1-modules.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['cryptography-kotlin-cryptography-serialization-asn1-modules'] = factory(typeof globalThis['cryptography-kotlin-cryptography-serialization-asn1-modules'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-serialization-asn1-modules']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-serialization-asn1-modules.js.map

package/cryptography-kotlin-cryptography-serialization-asn1-modules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/cryptography-kotlin-cryptography-serialization-asn1.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['cryptography-kotlin-cryptography-serialization-asn1'] = factory(typeof globalThis['cryptography-kotlin-cryptography-serialization-asn1'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-serialization-asn1']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-serialization-asn1.js.map

package/cryptography-kotlin-cryptography-serialization-asn1.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/cryptography-kotlin-cryptography-serialization-pem.js

@@ -0,0 +1,15 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    globalThis['cryptography-kotlin-cryptography-serialization-pem'] = factory(typeof globalThis['cryptography-kotlin-cryptography-serialization-pem'] === 'undefined' ? {} : globalThis['cryptography-kotlin-cryptography-serialization-pem']);
+}(function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-serialization-pem.js.map