@kaiko.io/rescript-deser 6.0.1 → 7.0.0-alpha.2

package/lib/es6/src/Deser.js

@@ -1,607 +1,435 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Js_json from "rescript/lib/es6/js_json.js";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
-import * as Core__Dict from "@rescript/core/lib/es6/src/Core__Dict.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
-import * as Core__Array from "@rescript/core/lib/es6/src/Core__Array.js";
-import * as Core__Option from "@rescript/core/lib/es6/src/Core__Option.js";
-import * as Core__Result from "@rescript/core/lib/es6/src/Core__Result.js";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.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_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var FieldValue = {};
+let FieldValue = {};
 
-var $$TypeError = /* @__PURE__ */Caml_exceptions.create("Deser.TypeError");
+let $$TypeError = /* @__PURE__ */Primitive_exceptions.create("Deser.TypeError");
 
 function usingString(f) {
-  return function (value) {
-    return f(value);
-  };
+  return value => f(value);
 }
 
 function usingInt(f) {
-  return function (value) {
-    return f(value);
-  };
+  return value => f(value);
 }
 
 function usingFloat(f) {
-  return function (value) {
-    return f(value);
-  };
+  return value => f(value);
 }
 
 function usingBoolean(f) {
-  return function (value) {
-    return f(value);
-  };
+  return value => f(value);
 }
 
 function usingArray(f) {
-  return function (value) {
-    return f(value);
-  };
+  return value => f(value);
 }
 
 function usingObject(f) {
-  return function (value) {
-    return f(value);
-  };
+  return value => f(value);
 }
 
 function variadicInt(hint, fromJs) {
   return {
-          TAG: "Morphism",
-          _0: "Int",
-          _1: (function (value) {
-              var internalValue = fromJs(value);
-              if (internalValue !== undefined) {
-                return Caml_option.valFromOption(internalValue);
-              }
-              throw {
-                    RE_EXN_ID: $$TypeError,
-                    _1: "This Int(" + value.toString() + ") not a valid value here. Hint: " + hint,
-                    Error: new Error()
-                  };
-            })
-        };
+    TAG: "Morphism",
+    _0: "Int",
+    _1: value => {
+      let internalValue = fromJs(value);
+      if (internalValue !== undefined) {
+        return Primitive_option.valFromOption(internalValue);
+      }
+      throw {
+        RE_EXN_ID: $$TypeError,
+        _1: `This Int(` + value.toString() + `) not a valid value here. Hint: ` + hint,
+        Error: new Error()
+      };
+    }
+  };
 }
 
 function variadicString(hint, fromJs) {
   return {
-          TAG: "Morphism",
-          _0: "String",
-          _1: (function (value) {
-              var internalValue = fromJs(value);
-              if (internalValue !== undefined) {
-                return Caml_option.valFromOption(internalValue);
-              }
-              throw {
-                    RE_EXN_ID: $$TypeError,
-                    _1: "This String(\"" + value + "\") not a valid value here. Hint: " + hint,
-                    Error: new Error()
-                  };
-            })
-        };
+    TAG: "Morphism",
+    _0: "String",
+    _1: value => {
+      let internalValue = fromJs(value);
+      if (internalValue !== undefined) {
+        return Primitive_option.valFromOption(internalValue);
+      }
+      throw {
+        RE_EXN_ID: $$TypeError,
+        _1: `This String("` + value + `") not a valid value here. Hint: ` + hint,
+        Error: new Error()
+      };
+    }
+  };
 }
 
 function toString(type_) {
   if (typeof type_ !== "object") {
     switch (type_) {
       case "Any" :
-          return "Any";
+        return "Any";
       case "String" :
-          return "String";
+        return "String";
       case "Int" :
-          return "Integer";
+        return "Integer";
       case "Float" :
-          return "Float";
+        return "Float";
       case "Boolean" :
-          return "Boolean";
+        return "Boolean";
       case "Date" :
       case "Datetime" :
-          return "Date";
+        return "Date";
       case "Self" :
-          return "Self (recursive)";
-      
+        return "Self (recursive)";
     }
   } else {
     switch (type_.TAG) {
       case "Literal" :
-          return "Literal: " + type_._0;
+        return `Literal: ` + type_._0;
       case "Array" :
-          return "Array of " + toString(type_._0);
+        return "Array of " + toString(type_._0);
       case "Tuple" :
-          return "Tuple of (" + type_._0.map(toString).join(", ") + ")";
+        return `Tuple of (` + type_._0.map(toString).join(", ") + `)`;
       case "Object" :
-          var desc = type_._0.map(function (param) {
-                  return param[0] + ": " + toString(param[1]);
-                }).join(", ");
-          return "Object of {" + desc + "}";
+        let desc = type_._0.map(param => param[0] + `: ` + toString(param[1])).join(", ");
+        return `Object of {` + desc + `}`;
       case "Optional" :
       case "OptionalWithDefault" :
-          return "Null of " + toString(type_._0);
+        return "Null of " + toString(type_._0);
       case "Mapping" :
-          return "Mapping of " + toString(type_._0);
+        return `Mapping of ` + toString(type_._0);
       case "Deserializer" :
-          return type_._0.name;
+        return type_._0.name;
       case "Collection" :
-          return "Collection of " + type_._0.name;
+        return "Collection of " + type_._0.name;
       case "DefaultWhenInvalid" :
-          return "Protected " + toString(type_._0);
+        return `Protected ` + toString(type_._0);
       case "Morphism" :
-          return toString(type_._0) + " to apply a morphism";
-      
+        return toString(type_._0) + " to apply a morphism";
     }
   }
 }
 
 function _taggedToString(tagged) {
-  if (typeof tagged !== "object") {
-    switch (tagged) {
-      case "JSONFalse" :
-          return "Boolean(false)";
-      case "JSONTrue" :
-          return "Boolean(true)";
-      case "JSONNull" :
-          return "Null";
-      
-    }
-  } else {
-    switch (tagged.TAG) {
-      case "JSONString" :
-          return "String(\"" + tagged._0 + "\")";
-      case "JSONNumber" :
-          return "Number(" + tagged._0.toString() + ")";
-      case "JSONObject" :
-          return "Object(" + Core__Option.getOr(JSON.stringify(tagged._0), "...") + ")";
-      case "JSONArray" :
-          return "Array(" + Core__Option.getOr(JSON.stringify(tagged._0), "...") + ")";
-      
-    }
+  if (tagged === null) {
+    return "Null";
+  }
+  if (Array.isArray(tagged)) {
+    return `Array(` + Stdlib_Option.getOr(JSON.stringify(tagged), "...") + `)`;
+  }
+  switch (typeof tagged) {
+    case "boolean" :
+      if (tagged) {
+        return "Boolean(true)";
+      } else {
+        return "Boolean(false)";
+      }
+    case "string" :
+      return `String("` + tagged + `")`;
+    case "number" :
+      return `Number(` + tagged.toString() + `)`;
+    case "object" :
+      return `Object(` + Stdlib_Option.getOr(JSON.stringify(tagged), "...") + `)`;
   }
 }
 
 function extractValue(values, field, shape, self) {
-  var value = values[field];
+  let value = values[field];
   if (value !== undefined) {
     return fromUntagged(value, shape, self);
   }
   if (typeof shape === "object") {
     switch (shape.TAG) {
       case "OptionalWithDefault" :
-          return shape._1;
+        return shape._1;
       case "Optional" :
       case "DefaultWhenInvalid" :
-          return fromUntagged(null, shape, self);
-      default:
-        
+        return fromUntagged(null, shape, self);
     }
   }
   throw {
-        RE_EXN_ID: $$TypeError,
-        _1: "Missing non-optional field '" + field + "'",
-        Error: new Error()
-      };
+    RE_EXN_ID: $$TypeError,
+    _1: `Missing non-optional field '` + field + `'`,
+    Error: new Error()
+  };
 }
 
 function fromUntagged(untagged, _shape, self) {
-  while(true) {
-    var shape = _shape;
-    var match = Js_json.classify(untagged);
-    var exit = 0;
-    var s;
-    var f;
+  while (true) {
+    let shape = _shape;
+    let exit = 0;
     if (typeof shape !== "object") {
       switch (shape) {
         case "Any" :
-            return untagged;
+          return untagged;
         case "String" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONString") {
-                return match._0;
-              }
-              exit = 1;
-            }
-            break;
+          if (typeof untagged === "string") {
+            return untagged;
+          }
+          break;
         case "Int" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONNumber") {
-                return match._0 | 0;
-              }
-              exit = 1;
-            }
-            break;
+          if (typeof untagged === "number") {
+            return untagged | 0;
+          }
+          break;
         case "Float" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONNumber") {
-                return match._0;
-              }
-              exit = 1;
-            }
-            break;
+          if (typeof untagged === "number") {
+            return untagged;
+          }
+          break;
         case "Boolean" :
-            if (typeof match !== "object") {
-              switch (match) {
-                case "JSONFalse" :
-                    return false;
-                case "JSONTrue" :
-                    return true;
-                default:
-                  exit = 1;
-              }
-            } else {
-              exit = 1;
-            }
-            break;
+          if (typeof untagged === "boolean") {
+            return untagged;
+          }
+          break;
         case "Date" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              switch (match.TAG) {
-                case "JSONString" :
-                    s = match._0;
-                    exit = 2;
-                    break;
-                case "JSONNumber" :
-                    f = match._0;
-                    exit = 3;
-                    break;
-                default:
-                  exit = 1;
-              }
-            }
-            break;
         case "Datetime" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              switch (match.TAG) {
-                case "JSONString" :
-                    s = match._0;
-                    exit = 2;
-                    break;
-                case "JSONNumber" :
-                    f = match._0;
-                    exit = 3;
-                    break;
-                default:
-                  exit = 1;
-              }
-            }
-            break;
+          exit = 2;
+          break;
         case "Self" :
-            _shape = self;
-            continue ;
-        
+          _shape = self;
+          continue;
       }
     } else {
       switch (shape.TAG) {
         case "Literal" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONString") {
-                var text = match._0;
-                var expected = shape._0;
-                if (text === expected) {
-                  return text;
-                }
-                throw {
-                      RE_EXN_ID: $$TypeError,
-                      _1: "Expecting literal " + expected + ", got " + text,
-                      Error: new Error()
-                    };
-              }
-              exit = 1;
+          if (typeof untagged === "string") {
+            let expected = shape._0;
+            if (untagged === expected) {
+              return untagged;
             }
-            break;
+            throw {
+              RE_EXN_ID: $$TypeError,
+              _1: `Expecting literal ` + expected + `, got ` + untagged,
+              Error: new Error()
+            };
+          }
+          break;
         case "Array" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONArray") {
-                var shape$1 = shape._0;
-                return match._0.map((function(shape$1){
-                          return function (item) {
-                            return fromUntagged(item, shape$1, self);
-                          }
-                          }(shape$1)));
-              }
-              exit = 1;
-            }
-            break;
+          if (Array.isArray(untagged)) {
+            let shape$1 = shape._0;
+            return untagged.map(item => fromUntagged(item, shape$1, self));
+          }
+          break;
         case "Tuple" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONArray") {
-                var items = match._0;
-                var bases = shape._0;
-                var lenbases = bases.length;
-                var lenitems = items.length;
-                if (lenbases === lenitems) {
-                  return Belt_Array.zipBy(items, bases, (function (i, b) {
-                                return fromUntagged(i, b, self);
-                              }));
-                }
-                throw {
-                      RE_EXN_ID: $$TypeError,
-                      _1: "Expecting " + lenbases.toString() + " items, got " + lenitems.toString(),
-                      Error: new Error()
-                    };
-              }
-              exit = 1;
+          if (Array.isArray(untagged)) {
+            let bases = shape._0;
+            let lenbases = bases.length;
+            let lenitems = untagged.length;
+            if (lenbases === lenitems) {
+              return Belt_Array.zipBy(untagged, bases, (i, b) => fromUntagged(i, b, self));
             }
-            break;
+            throw {
+              RE_EXN_ID: $$TypeError,
+              _1: `Expecting ` + lenbases.toString() + ` items, got ` + lenitems.toString(),
+              Error: new Error()
+            };
+          }
+          break;
         case "Object" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONObject") {
-                var values = match._0;
-                return Object.fromEntries(shape._0.map((function(values){
-                              return function (param) {
-                                var field = param[0];
-                                var value;
-                                try {
-                                  value = extractValue(values, field, param[1], self);
-                                }
-                                catch (raw_msg){
-                                  var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
-                                  if (msg.RE_EXN_ID === $$TypeError) {
-                                    throw {
-                                          RE_EXN_ID: $$TypeError,
-                                          _1: "Field \"" + field + "\": " + msg._1,
-                                          Error: new Error()
-                                        };
-                                  }
-                                  throw msg;
-                                }
-                                return [
-                                        field,
-                                        value
-                                      ];
-                              }
-                              }(values))));
+          if (typeof untagged === "object" && untagged !== null && !Array.isArray(untagged)) {
+            return Object.fromEntries(shape._0.map(param => {
+              let field = param[0];
+              let value;
+              try {
+                value = extractValue(untagged, field, param[1], self);
+              } catch (raw_msg) {
+                let msg = Primitive_exceptions.internalToException(raw_msg);
+                if (msg.RE_EXN_ID === $$TypeError) {
+                  throw {
+                    RE_EXN_ID: $$TypeError,
+                    _1: `Field "` + field + `": ` + msg._1,
+                    Error: new Error()
+                  };
+                }
+                throw msg;
               }
-              exit = 1;
-            }
-            break;
+              return [
+                field,
+                value
+              ];
+            }));
+          }
+          break;
         case "Optional" :
-            var shape$2 = shape._0;
-            if (typeof match !== "object") {
-              if (match === "JSONNull") {
-                return undefined;
-              }
-              _shape = shape$2;
-              continue ;
-            } else {
-              _shape = shape$2;
-              continue ;
-            }
+          if (untagged === null) {
+            return undefined;
+          }
+          _shape = shape._0;
+          continue;
         case "OptionalWithDefault" :
-            var shape$3 = shape._0;
-            if (typeof match !== "object") {
-              if (match === "JSONNull") {
-                return shape._1;
-              }
-              _shape = shape$3;
-              continue ;
-            } else {
-              _shape = shape$3;
-              continue ;
-            }
+          if (untagged === null) {
+            return shape._1;
+          }
+          _shape = shape._0;
+          continue;
         case "Mapping" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONObject") {
-                var f$1 = shape._0;
-                return Core__Dict.mapValues(match._0, (function(f$1){
-                          return function (v) {
-                            return fromUntagged(v, f$1, self);
-                          }
-                          }(f$1)));
-              }
-              exit = 1;
-            }
-            break;
+          if (typeof untagged === "object" && untagged !== null && !Array.isArray(untagged)) {
+            let f = shape._0;
+            return Stdlib_Dict.mapValues(untagged, v => fromUntagged(v, f, self));
+          }
+          break;
         case "Deserializer" :
-            var res = shape._0.fromJSON(untagged);
-            if (res.TAG === "Ok") {
-              return res._0;
-            }
-            throw {
-                  RE_EXN_ID: $$TypeError,
-                  _1: res._0,
-                  Error: new Error()
-                };
+          let res = shape._0.fromJSON(untagged);
+          if (res.TAG === "Ok") {
+            return res._0;
+          }
+          throw {
+            RE_EXN_ID: $$TypeError,
+            _1: res._0,
+            Error: new Error()
+          };
         case "Collection" :
-            if (typeof match !== "object") {
-              exit = 1;
-            } else {
-              if (match.TAG === "JSONArray") {
-                return Core__Array.filterMap(match._0.map(shape._0.fromJSON), (function (x) {
-                                if (x.TAG === "Ok") {
-                                  return Caml_option.some(x._0);
-                                }
-                                console.warn("Deser", "Could not deserialize value in the collection", x._0);
-                              })).map(function (prim) {
-                            return prim;
-                          });
+          if (Array.isArray(untagged)) {
+            return Stdlib_Array.filterMap(untagged.map(shape._0.fromJSON), x => {
+              if (x.TAG === "Ok") {
+                return Primitive_option.some(x._0);
               }
-              exit = 1;
-            }
-            break;
+              console.warn("Deser", "Could not deserialize value in the collection", x._0);
+            }).map(prim => prim);
+          }
+          break;
         case "DefaultWhenInvalid" :
-            try {
-              return fromUntagged(untagged, shape._0, self);
-            }
-            catch (raw_msg){
-              var msg = Caml_js_exceptions.internalToOCamlException(raw_msg);
-              if (msg.RE_EXN_ID === $$TypeError) {
-                console.warn("Detected and ignore (with default): ", msg._1);
-                return shape._1;
-              }
-              throw msg;
+          try {
+            return fromUntagged(untagged, shape._0, self);
+          } catch (raw_msg) {
+            let msg = Primitive_exceptions.internalToException(raw_msg);
+            if (msg.RE_EXN_ID === $$TypeError) {
+              console.warn("Detected and ignore (with default): ", msg._1);
+              return shape._1;
             }
+            throw msg;
+          }
         case "Morphism" :
-            return shape._1(fromUntagged(untagged, shape._0, self));
-        
+          return shape._1(fromUntagged(untagged, shape._0, self));
       }
     }
-    switch (exit) {
-      case 1 :
-          throw {
-                RE_EXN_ID: $$TypeError,
-                _1: "Expected " + toString(shape) + ", but got " + _taggedToString(match) + " instead",
-                Error: new Error()
-              };
-      case 2 :
-          var r = new Date(s);
+    if (exit === 2) {
+      switch (typeof untagged) {
+        case "string" :
+          let r = new Date(untagged);
           if (Number.isNaN(r.getDate())) {
             throw {
-                  RE_EXN_ID: $$TypeError,
-                  _1: "Invalid date " + s,
-                  Error: new Error()
-                };
+              RE_EXN_ID: $$TypeError,
+              _1: `Invalid date ` + untagged,
+              Error: new Error()
+            };
           }
           return r;
-      case 3 :
-          var r$1 = new Date(f);
+        case "number" :
+          let r$1 = new Date(untagged);
           if (Number.isNaN(r$1.getDate())) {
             throw {
-                  RE_EXN_ID: $$TypeError,
-                  _1: "Invalid date " + f.toString(),
-                  Error: new Error()
-                };
+              RE_EXN_ID: $$TypeError,
+              _1: `Invalid date ` + untagged.toString(),
+              Error: new Error()
+            };
           }
           return r$1;
-      
+      }
     }
+    throw {
+      RE_EXN_ID: $$TypeError,
+      _1: `Expected ` + toString(shape) + `, but got ` + _taggedToString(untagged) + ` instead`,
+      Error: new Error()
+    };
   };
 }
 
 function checkFieldsSanity(name, _fields, _optional) {
-  while(true) {
-    var optional = _optional;
-    var fields = _fields;
-    var exit = 0;
+  while (true) {
+    let optional = _optional;
+    let fields = _fields;
+    let exit = 0;
     if (typeof fields !== "object") {
       switch (fields) {
         case "Self" :
-            if (optional) {
-              return {
-                      TAG: "Ok",
-                      _0: undefined
-                    };
-            } else {
-              return {
-                      TAG: "Error",
-                      _0: name + ": Trivial infinite recursion 'let fields = Self'"
-                    };
-            }
+          if (optional) {
+            return {
+              TAG: "Ok",
+              _0: undefined
+            };
+          } else {
+            return {
+              TAG: "Error",
+              _0: name + `: Trivial infinite recursion 'let fields = Self'`
+            };
+          }
         default:
           return {
-                  TAG: "Ok",
-                  _0: undefined
-                };
+            TAG: "Ok",
+            _0: undefined
+          };
       }
     } else {
       switch (fields.TAG) {
         case "Tuple" :
-            return Core__Result.map(Core__Array.reduce(fields._0.map((function(optional){
-                              return function (field, index) {
-                                return function () {
-                                  return checkFieldsSanity(name + "[" + index.toString() + "]", field, optional);
-                                };
-                              }
-                              }(optional))), {
-                            TAG: "Ok",
-                            _0: []
-                          }, (function (res, nextitem) {
-                              return Core__Result.flatMap(res, (function (arr) {
-                                            return Core__Result.map(nextitem(), (function (i) {
-                                                          return arr.concat([i]);
-                                                        }));
-                                          }));
-                            })), (function (param) {
-                          
-                        }));
+          return Stdlib_Result.map(Stdlib_Array.reduce(fields._0.map((field, index) => (() => checkFieldsSanity(name + `[` + index.toString() + `]`, field, optional))), {
+            TAG: "Ok",
+            _0: []
+          }, (res, nextitem) => Stdlib_Result.flatMap(res, arr => Stdlib_Result.map(nextitem(), i => arr.concat([i])))), param => {});
         case "Object" :
-            return Core__Result.map(Core__Array.reduce(fields._0.map((function(optional){
-                              return function (param) {
-                                var field = param[1];
-                                var fieldName = param[0];
-                                return function () {
-                                  return checkFieldsSanity(name + "::" + fieldName, field, optional);
-                                };
-                              }
-                              }(optional))), {
-                            TAG: "Ok",
-                            _0: []
-                          }, (function (res, nextitem) {
-                              return Core__Result.flatMap(res, (function (arr) {
-                                            return Core__Result.map(nextitem(), (function (i) {
-                                                          return arr.concat([i]);
-                                                        }));
-                                          }));
-                            })), (function (param) {
-                          
-                        }));
+          return Stdlib_Result.map(Stdlib_Array.reduce(fields._0.map(param => {
+            let field = param[1];
+            let fieldName = param[0];
+            return () => checkFieldsSanity(name + `::` + fieldName, field, optional);
+          }), {
+            TAG: "Ok",
+            _0: []
+          }, (res, nextitem) => Stdlib_Result.flatMap(res, arr => Stdlib_Result.map(nextitem(), i => arr.concat([i])))), param => {});
         case "Array" :
         case "Mapping" :
-            _optional = true;
-            _fields = fields._0;
-            continue ;
+          _optional = true;
+          _fields = fields._0;
+          continue;
         case "Deserializer" :
         case "Collection" :
-            exit = 2;
-            break;
+          exit = 2;
+          break;
         case "Optional" :
         case "OptionalWithDefault" :
         case "DefaultWhenInvalid" :
-            exit = 1;
-            break;
+          exit = 1;
+          break;
         default:
           return {
-                  TAG: "Ok",
-                  _0: undefined
-                };
+            TAG: "Ok",
+            _0: undefined
+          };
       }
     }
     switch (exit) {
       case 1 :
-          _optional = true;
-          _fields = fields._0;
-          continue ;
+        _optional = true;
+        _fields = fields._0;
+        continue;
       case 2 :
-          var msg = fields._0.checkFieldsSanity();
-          if (msg.TAG === "Ok") {
-            return {
-                    TAG: "Ok",
-                    _0: undefined
-                  };
-          } else {
-            return {
-                    TAG: "Error",
-                    _0: name + "/ " + msg._0
-                  };
-          }
-      
+        let msg = fields._0.checkFieldsSanity();
+        if (msg.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: undefined
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: name + `/ ` + msg._0
+          };
+        }
     }
   };
 }
 
-var Field = {
+let Field = {
   usingString: usingString,
   usingInt: usingInt,
   usingFloat: usingFloat,
@@ -618,42 +446,39 @@ var Field = {
 };
 
 function MakeDeserializer(S) {
-  var fields = S.fields;
-  var name = "Deserializer " + "Deser" + ", " + "File \"Deser.res\", line 329, characters 39-47";
-  var checkFieldsSanity$1 = function () {
-    return checkFieldsSanity(name, fields, false);
-  };
-  var fromJSON = function (json) {
-    var res;
+  let fields = S.fields;
+  let name = `Deserializer ` + "Deser" + `, ` + "File \"Deser.res\", line 318, characters 39-47";
+  let checkFieldsSanity$1 = () => checkFieldsSanity(name, fields, false);
+  let fromJSON = json => {
+    let res;
     try {
       res = fromUntagged(json, fields, fields);
-    }
-    catch (raw_e){
-      var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+    } catch (raw_e) {
+      let e = Primitive_exceptions.internalToException(raw_e);
       if (e.RE_EXN_ID === $$TypeError) {
         return {
-                TAG: "Error",
-                _0: e._1
-              };
+          TAG: "Error",
+          _0: e._1
+        };
       }
       throw e;
     }
     return {
-            TAG: "Ok",
-            _0: res
-          };
+      TAG: "Ok",
+      _0: res
+    };
   };
   return {
-          name: name,
-          fromJSON: fromJSON,
-          checkFieldsSanity: checkFieldsSanity$1
-        };
+    name: name,
+    fromJSON: fromJSON,
+    checkFieldsSanity: checkFieldsSanity$1
+  };
 }
 
 export {
-  FieldValue ,
-  $$TypeError ,
-  Field ,
-  MakeDeserializer ,
+  FieldValue,
+  $$TypeError,
+  Field,
+  MakeDeserializer,
 }
 /* No side effect */