envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/Utils.res.mjs

@@ -1,91 +1,81 @@
 import packageJson from '../package.json' with { type: 'json' }
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as $$Array from "rescript/lib/es6/array.js";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
-import * as Js_dict from "rescript/lib/es6/js_dict.js";
-import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
-import * as Caml_array from "rescript/lib/es6/caml_array.js";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
-import * as Caml_splice_call from "rescript/lib/es6/caml_splice_call.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function delay(milliseconds) {
-  return new Promise((function (resolve, param) {
-                setTimeout((function () {
-                        resolve();
-                      }), milliseconds);
-              }));
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), milliseconds);
+  });
 }
 
-var $$Object = {};
+let $$Object = {};
 
-var $$Error = {};
+let $$Error = {};
 
 function mapNone(opt, val) {
   if (opt !== undefined) {
-    return ;
+    return;
   } else {
-    return Caml_option.some(val);
+    return Primitive_option.some(val);
   }
 }
 
 function catchToNone(unsafeFunc) {
   try {
-    return Caml_option.some(unsafeFunc());
-  }
-  catch (exn){
-    return ;
+    return Primitive_option.some(unsafeFunc());
+  } catch (exn) {
+    return;
   }
 }
 
 function flatten(opt) {
   if (opt !== undefined) {
-    return Caml_option.valFromOption(opt);
+    return Primitive_option.valFromOption(opt);
   }
-  
 }
 
 function getExn(opt, message) {
   if (opt !== undefined) {
-    return Caml_option.valFromOption(opt);
+    return Primitive_option.valFromOption(opt);
   } else {
-    return Js_exn.raiseError(message);
+    return Stdlib_JsError.throwWithMessage(message);
   }
 }
 
-var $$Option = {
+let Option = {
   mapNone: mapNone,
   catchToNone: catchToNone,
   flatten: flatten,
   getExn: getExn
 };
 
-function get(tuple, index) {
-  return (tuple[index]);
-}
-
-var Tuple = {
-  get: get
-};
-
 function getOrInsertEmptyDict(dict, key) {
-  var d = dict[key];
+  let d = dict[key];
   if (d !== undefined) {
     return d;
   }
-  var d$1 = {};
+  let d$1 = {};
   dict[key] = d$1;
   return d$1;
 }
 
-var has = ((dict, key) => key in dict);
+let has = ((dict, key) => key in dict);
 
 function push(dict, key, value) {
-  var arr = dict[key];
+  let arr = dict[key];
   if (arr !== undefined) {
     arr.push(value);
   } else {
@@ -94,17 +84,17 @@ function push(dict, key, value) {
 }
 
 function pushMany(dict, key, values) {
-  var arr = dict[key];
+  let arr = dict[key];
   if (arr !== undefined) {
-    Caml_splice_call.spliceObjApply(arr, "push", [values]);
+    arr.push(...values);
   } else {
     dict[key] = values;
   }
 }
 
-var merge = ((dictA, dictB) => ({...dictA, ...dictB}));
+let merge = ((dictA, dictB) => ({...dictA, ...dictB}));
 
-var mapValues = ((dict, f) => {
+let mapValues = ((dict, f) => {
     var target = {}, i;
     for (i in dict) {
       target[i] = f(dict[i]);
@@ -112,7 +102,7 @@ var mapValues = ((dict, f) => {
     return target;
   });
 
-var filterMapValues = ((dict, f) => {
+let filterMapValues = ((dict, f) => {
     var target = {}, i, v;
     for (i in dict) {
       v = f(dict[i]);
@@ -123,7 +113,7 @@ var filterMapValues = ((dict, f) => {
     return target;
   });
 
-var mapValuesToArray = ((dict, f) => {
+let mapValuesToArray = ((dict, f) => {
     var target = [], i;
     for (i in dict) {
       target.push(f(dict[i]));
@@ -131,19 +121,19 @@ var mapValuesToArray = ((dict, f) => {
     return target;
   });
 
-var forEach = ((dict, f) => {
+let forEach = ((dict, f) => {
     for (var i in dict) {
       f(dict[i]);
     }
   });
 
-var forEachWithKey = ((dict, f) => {
+let forEachWithKey = ((dict, f) => {
     for (var i in dict) {
       f(dict[i], i);
     }
   });
 
-var size = ((dict) => {
+let size = ((dict) => {
     var size = 0, i;
     for (i in dict) {
       size++;
@@ -151,18 +141,18 @@ var size = ((dict) => {
     return size;
   });
 
-var isEmpty = ((dict) => {
+let isEmpty = ((dict) => {
     for (var _ in dict) {
       return false
     }
     return true
   });
 
-var deleteInPlace = ((dict, key) => {
+let deleteInPlace = ((dict, key) => {
       delete dict[key];
     });
 
-var unsafeDeleteUndefinedFieldsInPlace = ((dict) => {
+let unsafeDeleteUndefinedFieldsInPlace = ((dict) => {
       for (var key in dict) {
         if (dict[key] === undefined) {
           delete dict[key];
@@ -170,15 +160,16 @@ var unsafeDeleteUndefinedFieldsInPlace = ((dict) => {
       }
     });
 
-var updateImmutable = ((dict, key, value) => ({...dict, [key]: value}));
+let updateImmutable = ((dict, key, value) => ({...dict, [key]: value}));
 
-var shallowCopy = ((dict) => ({...dict}));
+let shallowCopy = ((dict) => ({...dict}));
 
-var incrementByInt = ((dict, key) => {
+let incrementByInt = ((dict, key) => {
     dict[key]++
   });
 
-var Dict = {
+let Dict = {
+  $$delete: Stdlib_Dict.$$delete,
   getOrInsertEmptyDict: getOrInsertEmptyDict,
   has: has,
   push: push,
@@ -201,26 +192,26 @@ var Dict = {
 function minOptInt(a, b) {
   if (a === undefined) {
     if (b !== undefined) {
-      return Caml_option.some(Caml_option.valFromOption(b));
+      return Primitive_option.some(Primitive_option.valFromOption(b));
     } else {
-      return ;
+      return;
     }
   }
-  var a$1 = Caml_option.valFromOption(a);
+  let a$1 = Primitive_option.valFromOption(a);
   if (b === undefined) {
-    return Caml_option.some(a$1);
+    return Primitive_option.some(a$1);
   }
-  var b$1 = Caml_option.valFromOption(b);
-  return Caml_option.some(Caml_obj.lessthan(a$1, b$1) ? a$1 : b$1);
+  let b$1 = Primitive_option.valFromOption(b);
+  return Primitive_option.some(Primitive_object.lessthan(a$1, b$1) ? a$1 : b$1);
 }
 
-var $$Math = {
+let $$Math = {
   minOptInt: minOptInt
 };
 
-var UnsafeIntOperators = {};
+let UnsafeIntOperators = {};
 
-var immutableEmpty = [];
+let immutableEmpty = [];
 
 function mergeSorted(f, xs, ys) {
   if (xs.length === 0) {
@@ -229,79 +220,77 @@ function mergeSorted(f, xs, ys) {
   if (ys.length === 0) {
     return xs;
   }
-  var n = xs.length + ys.length | 0;
-  var result = Array(n);
-  var loop = function (_i, _j, _k) {
-    while(true) {
-      var k = _k;
-      var j = _j;
-      var i = _i;
+  let n = xs.length + ys.length | 0;
+  let result = Array(n);
+  let loop = (_i, _j, _k) => {
+    while (true) {
+      let k = _k;
+      let j = _j;
+      let i = _i;
       if (i < xs.length && j < ys.length) {
-        if (f(Caml_array.get(xs, i), Caml_array.get(ys, j))) {
-          Caml_array.set(result, k, Caml_array.get(xs, i));
+        if (f(xs[i], ys[j])) {
+          result[k] = xs[i];
           _k = k + 1 | 0;
           _i = i + 1 | 0;
-          continue ;
+          continue;
         }
-        Caml_array.set(result, k, Caml_array.get(ys, j));
+        result[k] = ys[j];
         _k = k + 1 | 0;
         _j = j + 1 | 0;
-        continue ;
+        continue;
       }
       if (i < xs.length) {
-        Caml_array.set(result, k, Caml_array.get(xs, i));
+        result[k] = xs[i];
         _k = k + 1 | 0;
         _i = i + 1 | 0;
-        continue ;
+        continue;
       }
       if (j >= ys.length) {
-        return ;
+        return;
       }
-      Caml_array.set(result, k, Caml_array.get(ys, j));
+      result[k] = ys[j];
       _k = k + 1 | 0;
       _j = j + 1 | 0;
-      continue ;
+      continue;
     };
   };
   loop(0, 0, 0);
   return result;
 }
 
-var clearInPlace = ((arr) => {
+let clearInPlace = ((arr) => {
     arr.length = 0
   });
 
 function setIndexImmutable(arr, index, value) {
-  var shallowCopy = arr.slice(0);
+  let shallowCopy = arr.slice(0);
   shallowCopy[index] = value;
   return shallowCopy;
 }
 
 function transposeResults(results) {
-  var _index = 0;
-  var output = new Array(results.length);
-  while(true) {
-    var index = _index;
+  let _index = 0;
+  let output = new Array(results.length);
+  while (true) {
+    let index = _index;
     if (index >= results.length) {
       return {
-              TAG: "Ok",
-              _0: output
-            };
+        TAG: "Ok",
+        _0: output
+      };
     }
-    var value = results[index];
+    let value = results[index];
     if (value.TAG !== "Ok") {
       return value;
     }
-    Caml_array.set(output, index, value._0);
+    output[index] = value._0;
     _index = index + 1 | 0;
-    continue ;
+    continue;
   };
 }
 
 function includes(arr, val) {
-  return Belt_Option.isSome(Caml_option.undefined_to_opt(arr.find(function (item) {
-                      return Caml_obj.equal(item, val);
-                    })));
+  return Belt_Option.isSome(arr.find(item => Primitive_object.equal(item, val)));
 }
 
 function isEmpty$1(arr) {
@@ -313,15 +302,15 @@ function notEmpty(arr) {
 }
 
 async function awaitEach(arr, fn) {
-  for(var i = 0 ,i_finish = arr.length; i < i_finish; ++i){
-    var item = Caml_array.get(arr, i);
+  for (let i = 0, i_finish = arr.length; i < i_finish; ++i) {
+    let item = arr[i];
     await fn(item);
   }
 }
 
 function removeAtIndex(array, index) {
   if (index < 0) {
-    return $$Array.copy(array);
+    return array.slice();
   } else {
     return array.slice(0, index).concat(array.slice(index + 1 | 0));
   }
@@ -344,38 +333,37 @@ function firstUnsafe(arr) {
 }
 
 function findReverseWithIndex(arr, fn) {
-  var _index = arr.length - 1 | 0;
-  while(true) {
-    var index = _index;
+  let _index = arr.length - 1 | 0;
+  while (true) {
+    let index = _index;
     if (index < 0) {
-      return ;
+      return;
     }
-    var item = Caml_array.get(arr, index);
+    let item = arr[index];
     if (fn(item)) {
       return [
-              item,
-              index
-            ];
+        item,
+        index
+      ];
     }
     _index = index - 1 | 0;
-    continue ;
+    continue;
   };
 }
 
 function interleave(arr, separator) {
-  var interleaved = [];
-  arr.forEach(function (v, i) {
-        interleaved.push(v);
-        if (i < (arr.length - 1 | 0)) {
-          interleaved.push(separator);
-          return ;
-        }
-        
-      });
+  let interleaved = [];
+  arr.forEach((v, i) => {
+    interleaved.push(v);
+    if (i < (arr.length - 1 | 0)) {
+      interleaved.push(separator);
+      return;
+    }
+  });
   return interleaved;
 }
 
-var fromAsyncIterator = (async (iterator) => {
+let fromAsyncIterator = (async (iterator) => {
     const result = [];
     for await (const item of iterator) {
       result.push(item);
@@ -383,7 +371,29 @@ var fromAsyncIterator = (async (iterator) => {
     return result;
   });
 
-var $$Array$1 = {
+let $$Array$1 = {
+  make: Stdlib_Array.make,
+  fromInitializer: Stdlib_Array.fromInitializer,
+  equal: Stdlib_Array.equal,
+  compare: Stdlib_Array.compare,
+  indexOfOpt: Stdlib_Array.indexOfOpt,
+  lastIndexOfOpt: Stdlib_Array.lastIndexOfOpt,
+  reduce: Stdlib_Array.reduce,
+  reduceWithIndex: Stdlib_Array.reduceWithIndex,
+  reduceRight: Stdlib_Array.reduceRight,
+  reduceRightWithIndex: Stdlib_Array.reduceRightWithIndex,
+  findIndexOpt: Stdlib_Array.findIndexOpt,
+  findLastIndexOpt: Stdlib_Array.findLastIndexOpt,
+  filterMap: Stdlib_Array.filterMap,
+  filterMapWithIndex: Stdlib_Array.filterMapWithIndex,
+  keepSome: Stdlib_Array.keepSome,
+  toShuffled: Stdlib_Array.toShuffled,
+  shuffle: Stdlib_Array.shuffle,
+  findMap: Stdlib_Array.findMap,
+  zip: Stdlib_Array.zip,
+  zipBy: Stdlib_Array.zipBy,
+  partition: Stdlib_Array.partition,
+  unzip: Stdlib_Array.unzip,
   immutableEmpty: immutableEmpty,
   mergeSorted: mergeSorted,
   clearInPlace: clearInPlace,
@@ -407,24 +417,32 @@ function capitalize(str) {
   return str.slice(0, 1).toUpperCase() + str.slice(1);
 }
 
-var $$String = {
+let $$String = {
+  charCodeAt: Stdlib_String.charCodeAt,
+  indexOfOpt: Stdlib_String.indexOfOpt,
+  lastIndexOfOpt: Stdlib_String.lastIndexOfOpt,
+  searchOpt: Stdlib_String.searchOpt,
+  isEmpty: Stdlib_String.isEmpty,
   capitalize: capitalize
 };
 
 function getHostFromUrl(url) {
-  var regex = /https?:\/\/([^\/?]+).*/;
-  var result = regex.exec(url);
-  if (result === null) {
-    return ;
+  let regex = /https?:\/\/([^\/?]+).*/;
+  let result = regex.exec(url);
+  if (result == null) {
+    return;
   }
-  var host = Belt_Array.get(result, 1);
+  let match = Belt_Array.get(result.slice(1), 0);
+  if (match === undefined) {
+    return;
+  }
+  let host = Primitive_option.valFromOption(match);
   if (host !== undefined) {
-    return Caml_option.nullable_to_opt(Caml_option.valFromOption(host));
+    return host;
   }
-  
 }
 
-var Url = {
+let Url = {
   getHostFromUrl: getHostFromUrl
 };
 
@@ -435,7 +453,7 @@ function forEach$1(result, fn) {
   return result;
 }
 
-var Result = {
+let Result = {
   forEach: forEach$1
 };
 
@@ -446,61 +464,49 @@ function unwrapResultExn(res) {
   throw res._0;
 }
 
-var variantTag = S$RescriptSchema.union([
-      S$RescriptSchema.string,
-      S$RescriptSchema.object(function (s) {
-            return s.f("TAG", S$RescriptSchema.string);
-          })
-    ]);
+let variantTag = S$RescriptSchema.union([
+  S$RescriptSchema.string,
+  S$RescriptSchema.object(s => s.f("TAG", S$RescriptSchema.string))
+]);
 
-var dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function (param) {
-        return {
-                s: (function (date) {
-                    return date.toISOString();
-                  })
-              };
-      }));
+let dbDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
+  s: date => date.toISOString()
+}));
 
-var clickHouseDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), (function (param) {
-        return {
-                s: (function (date) {
-                    return date.getTime();
-                  })
-              };
-      }));
+let clickHouseDate = S$RescriptSchema.preprocess(S$RescriptSchema.json(false), param => ({
+  s: date => date.getTime()
+}));
 
 function coerceToJsonPgType(schema) {
-  return S$RescriptSchema.preprocess(schema, (function (s) {
-                var match = s.schema.t;
-                if (typeof match === "object") {
-                  return {};
-                }
-                switch (match) {
-                  case "unknown" :
-                      return {
-                              s: (function (param) {
-                                  return "null";
-                                })
-                            };
-                  case "boolean" :
-                      return {
-                              s: (function (unknown) {
-                                  if (unknown === false) {
-                                    return "false";
-                                  } else if (unknown === true) {
-                                    return "true";
-                                  } else {
-                                    return unknown;
-                                  }
-                                })
-                            };
-                  default:
-                    return {};
-                }
-              }));
-}
-
-var Schema = {
+  return S$RescriptSchema.preprocess(schema, s => {
+    let match = s.schema.t;
+    if (typeof match === "object") {
+      return {};
+    }
+    switch (match) {
+      case "unknown" :
+        return {
+          s: param => ("null")
+        };
+      case "boolean" :
+        return {
+          s: unknown => {
+            if (unknown === false) {
+              return "false";
+            } else if (unknown === true) {
+              return "true";
+            } else {
+              return unknown;
+            }
+          }
+        };
+      default:
+        return {};
+    }
+  });
+}
+
+let Schema = {
   variantTag: variantTag,
   dbDate: dbDate,
   clickHouseDate: clickHouseDate,
@@ -508,180 +514,213 @@ var Schema = {
 };
 
 function getVariantsTags(variants) {
-  return variants.map(function (variant) {
-              return S$RescriptSchema.parseOrThrow(variant, variantTag);
-            });
+  return variants.map(variant => S$RescriptSchema.parseOrThrow(variant, variantTag));
 }
 
 function addMany(set, values) {
-  values.forEach(function (value) {
-        set.add(value);
-      });
+  values.forEach(value => {
+    set.add(value);
+  });
 }
 
-var immutableAdd = ((set, value) => {
+let immutableAdd = ((set, value) => {
     return new Set([...set, value])
   });
 
-var $$Set = {
+let $$Set = {
   addMany: addMany,
   immutableAdd: immutableAdd
 };
 
-var fromArray = Js_dict.fromArray;
+function fromArray(pairs) {
+  return Object.fromEntries(pairs);
+}
 
-var Record = {
+let Record = {
   fromArray: fromArray
 };
 
 function memoize(fn) {
-  var cache = new WeakMap();
-  return function (key) {
-    var v = cache.get(key);
+  let cache = new WeakMap();
+  return key => {
+    let v = cache.get(key);
     if (v !== undefined) {
-      return Caml_option.valFromOption(v);
+      return Primitive_option.valFromOption(v);
     }
-    var v$1 = fn(key);
+    let v$1 = fn(key);
     cache.set(key, v$1);
     return v$1;
   };
 }
 
-var $$WeakMap$1 = {
+let $$WeakMap$1 = {
   memoize: memoize
 };
 
-var $$Map = {};
+let $$Map = {};
 
-var $$Proxy = {};
+let $$Proxy = {};
 
 function fail(name) {
-  return Js_exn.raiseError("Failed to get hash for " + name + ". If you're using a custom Sury schema make it based on the string type with a decoder: const myTypeSchema = S.transform(S.string, undefined, (yourType) => yourType.toString())");
+  return Stdlib_JsError.throwWithMessage(`Failed to get hash for ` + name + `. If you're using a custom Sury schema make it based on the string type with a decoder: const myTypeSchema = S.transform(S.string, undefined, (yourType) => yourType.toString())`);
 }
 
 function makeOrThrow(any) {
-  var $$typeof = typeof any;
-  switch ($$typeof) {
-    case "bigint" :
-        return "\"" + any.toString() + "\"";
-    case "boolean" :
-        if (any) {
-          return "true";
-        } else {
-          return "false";
-        }
-    case "number" :
-        return any.toString();
-    case "object" :
-        if (any === null) {
-          return "null";
-        }
-        if (Array.isArray(any)) {
-          var hash = "[";
-          for(var i = 0 ,i_finish = any.length; i < i_finish; ++i){
-            if (i !== 0) {
-              hash = hash + ",";
-            }
-            hash = hash + makeOrThrow(any[i]);
-          }
-          return hash + "]";
-        }
-        var constructor = any["constructor"];
-        if (constructor !== Object) {
-          if (constructor.name === "BigNumber") {
-            return "\"" + any.toString() + "\"";
-          } else {
-            return fail(constructor.name);
-          }
-        }
-        var hash$1 = "{";
-        var keys = Object.keys(any).sort();
-        var isFirst = true;
-        for(var i$1 = 0 ,i_finish$1 = keys.length; i$1 < i_finish$1; ++i$1){
-          var key = keys[i$1];
-          var value = any[key];
-          if (value !== undefined) {
-            if (isFirst) {
-              isFirst = false;
-            } else {
-              hash$1 = hash$1 + ",";
-            }
-            hash$1 = hash$1 + ("\"" + key + "\":" + makeOrThrow(any[key]));
-          }
-          
-        }
-        return hash$1 + "}";
-    case "string" :
-        return "\"" + any + "\"";
-    case "function" :
-    case "symbol" :
-        return any.toString();
-    case "undefined" :
-        return "null";
-    default:
-      return fail($$typeof);
+  let match = typeof any;
+  if (match === "function" || match === "symbol") {
+    return any.toString();
+  }
+  if (match === "boolean") {
+    if (any) {
+      return "true";
+    } else {
+      return "false";
+    }
+  }
+  if (match === "string") {
+    return `"` + any + `"`;
+  }
+  if (match !== "object") {
+    if (match === "undefined") {
+      return "null";
+    } else if (match === "number") {
+      return any.toString();
+    } else {
+      return `"` + any.toString() + `"`;
+    }
+  }
+  if (any === null) {
+    return "null";
+  }
+  if (Array.isArray(any)) {
+    let hash = "[";
+    for (let i = 0, i_finish = any.length; i < i_finish; ++i) {
+      if (i !== 0) {
+        hash = hash + ",";
+      }
+      hash = hash + makeOrThrow(any[i]);
+    }
+    return hash + "]";
+  }
+  let constructor = any["constructor"];
+  if (constructor !== Object) {
+    if (constructor.name === "BigNumber") {
+      return `"` + any.toString() + `"`;
+    } else {
+      return fail(constructor.name);
+    }
   }
+  let hash$1 = "{";
+  let keys = Object.keys(any).toSorted(Primitive_string.compare);
+  let isFirst = true;
+  for (let i$1 = 0, i_finish$1 = keys.length; i$1 < i_finish$1; ++i$1) {
+    let key = keys[i$1];
+    let value = any[key];
+    if (value !== undefined) {
+      if (isFirst) {
+        isFirst = false;
+      } else {
+        hash$1 = hash$1 + ",";
+      }
+      hash$1 = hash$1 + (`"` + key + `":` + makeOrThrow(any[key]));
+    }
+  }
+  return hash$1 + "}";
 }
 
-var Hash = {
+let Hash = {
   fail: fail,
   makeOrThrow: makeOrThrow
 };
 
 function prettifyExn(exn) {
-  var e = Caml_js_exceptions.internalToOCamlException(exn);
-  if (e.RE_EXN_ID === Js_exn.$$Error) {
+  let e = Primitive_exceptions.internalToException(exn);
+  if (e.RE_EXN_ID === "JsExn") {
     return e._1;
   } else {
     return e;
   }
 }
 
-var value;
+let value;
 
 try {
-  value = S$RescriptSchema.parseJsonOrThrow(packageJson, S$RescriptSchema.schema(function (s) {
-            return {
-                    version: s.m(S$RescriptSchema.string)
-                  };
-          }));
-}
-catch (raw_error){
-  var error = Caml_js_exceptions.internalToOCamlException(raw_error);
+  value = S$RescriptSchema.parseJsonOrThrow(packageJson, S$RescriptSchema.schema(s => ({
+    version: s.m(S$RescriptSchema.string)
+  })));
+} catch (raw_error) {
+  let error = Primitive_exceptions.internalToException(raw_error);
   if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
-    value = Js_exn.raiseError("Failed to get package.json in envio package: " + S$RescriptSchema.$$Error.message(error._1));
+    value = Stdlib_JsError.throwWithMessage(`Failed to get package.json in envio package: ` + S$RescriptSchema.$$Error.message(error._1));
   } else {
     throw error;
   }
 }
 
-var EnvioPackage = {
+let EnvioPackage = {
   value: value
 };
 
+let arrayToStringArray = ((arr) => {
+    const res = new Array(arr.length);
+    for (let i = 0; i < arr.length; i++) {
+      res[i] = arr[i].toString();
+    }
+    return res;
+  });
+
+let schema = S$RescriptSchema.transform(S$RescriptSchema.setName(S$RescriptSchema.string, "BigInt"), s => ({
+  p: string => {
+    let bigInt = Stdlib_BigInt.fromString(string);
+    if (bigInt !== undefined) {
+      return bigInt;
+    } else {
+      return s.fail("The string is not valid BigInt", undefined);
+    }
+  },
+  s: bigint => bigint.toString()
+}));
+
+let $$BigInt = {
+  arrayToStringArray: arrayToStringArray,
+  schema: schema
+};
+
+function silentCatch(promise) {
+  return Stdlib_Promise.$$catch(promise, param => {});
+}
+
+let isCatchable = (value => value && typeof value.catch === 'function');
+
+let $$Promise$1 = {
+  silentCatch: silentCatch,
+  isCatchable: isCatchable
+};
+
 export {
-  delay ,
-  $$Object ,
-  $$Error ,
-  $$Option ,
-  Tuple ,
-  Dict ,
-  $$Math ,
-  UnsafeIntOperators ,
+  delay,
+  $$Object,
+  $$Error,
+  Option,
+  Dict,
+  $$Math,
+  UnsafeIntOperators,
   $$Array$1 as $$Array,
-  $$String ,
-  Url ,
-  Result ,
-  unwrapResultExn ,
-  Schema ,
-  getVariantsTags ,
-  $$Set ,
-  Record ,
+  $$String,
+  Url,
+  Result,
+  unwrapResultExn,
+  Schema,
+  getVariantsTags,
+  $$Set,
+  Record,
   $$WeakMap$1 as $$WeakMap,
-  $$Map ,
-  $$Proxy ,
-  Hash ,
-  prettifyExn ,
-  EnvioPackage ,
+  $$Map,
+  $$Proxy,
+  Hash,
+  prettifyExn,
+  EnvioPackage,
+  $$BigInt,
+  $$Promise$1 as $$Promise,
 }
 /* fromAsyncIterator Not a pure module */