@nfdi4plants/arctrl 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/ts/ts/fable_modules/Thoth.Json.Core.0.7.0/Decode.fs.js

@@ -0,0 +1,1251 @@
+import { ErrorReason$1_BadPrimitive, ErrorReason$1_BadPrimitiveExtra, ErrorReason$1_BadType, ErrorReason$1_BadPath, ErrorReason$1_BadField, ErrorReason$1_TooSmallArray, ErrorReason$1_BadOneOf, ErrorReason$1_FailMessage } from './Types.fs.js';
+import { join } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { map as map$1, tryLast, fold, empty, append, singleton, ofSeq, reverse as reverse$1, cons, isEmpty, head, tail, length } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { FSharpResult$2_Error, FSharpResult$2_Ok, Result_MapError, Result_Map } from '../../../node_modules/@fable-org/fable-library-js/Result.js';
+import { tryParse } from '../../../node_modules/@fable-org/fable-library-js/Guid.js';
+import { FSharpRef } from '../../../node_modules/@fable-org/fable-library-js/Types.js';
+import { tryParse as tryParse$1 } from '../../../node_modules/@fable-org/fable-library-js/Int32.js';
+import { toFloat64, toInt64, fromFloat64, toUInt64, fromInt32, tryParse as tryParse$3 } from '../../../node_modules/@fable-org/fable-library-js/BigInt.js';
+import { tryParse as tryParse$2 } from '../../../node_modules/@fable-org/fable-library-js/Long.js';
+import { tryParse as tryParse$4 } from '../../../node_modules/@fable-org/fable-library-js/Decimal.js';
+import { minValue, tryParse as tryParse$5, toUniversalTime } from '../../../node_modules/@fable-org/fable-library-js/Date.js';
+import { minValue as minValue$1, tryParse as tryParse$6 } from '../../../node_modules/@fable-org/fable-library-js/DateOffset.js';
+import { tryParse as tryParse$7 } from '../../../node_modules/@fable-org/fable-library-js/TimeSpan.js';
+import { some, defaultArg, value as value$1 } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { int32ToString, defaultOf, comparePrimitives, compare } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { item, fold as fold$1, setItem, fill } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { reverse, append as append$1, toList } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { class_type } from '../../../node_modules/@fable-org/fable-library-js/Reflection.js';
+import { ofList, ofSeq as ofSeq$1 } from '../../../node_modules/@fable-org/fable-library-js/Map.js';
+import { Big } from '../../../node_modules/@fable-org/fable-library-js/lib/big.js';
+
+function Helpers_prependPath(path, err_, err__1) {
+  const err = [err_, err__1];
+  return [path + err[0], err[1]];
+}
+function genericMsg(helpers, msg, value_1, newLine) {
+  try {
+    return "Expecting " + msg + " but instead got:" + (newLine ? "\n" : " ") + helpers.anyToString(value_1);
+  } catch (matchValue) {
+    return "Expecting " + msg + " but decoder failed. Couldn't report given value due to circular structure." + (newLine ? "\n" : " ");
+  }
+}
+function errorToString(helpers, path, error) {
+  let reason_1;
+  switch (error.tag) {
+    case /* BadType */
+    2: {
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], true);
+      break;
+    }
+    case /* BadPrimitiveExtra */
+    1: {
+      const reason = error.fields[2];
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], false) + "\nReason: " + reason;
+      break;
+    }
+    case /* BadField */
+    3: {
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], true);
+      break;
+    }
+    case /* BadPath */
+    4: {
+      const fieldName = error.fields[2];
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], true) + ("\nNode `" + fieldName + "` is unkown.");
+      break;
+    }
+    case /* TooSmallArray */
+    5: {
+      const value_6 = error.fields[1];
+      reason_1 = "Expecting " + error.fields[0] + ".\n" + helpers.anyToString(value_6);
+      break;
+    }
+    case /* BadOneOf */
+    7: {
+      reason_1 = "The following errors were found:\n\n" + join("\n\n", map$1((error_1) => {
+        const tupledArg = Helpers_prependPath(path, error_1[0], error_1[1]);
+        return errorToString(helpers, tupledArg[0], tupledArg[1]);
+      }, error.fields[0]));
+      break;
+    }
+    case /* FailMessage */
+    6: {
+      reason_1 = "The following `failure` occurred with the decoder: " + error.fields[0];
+      break;
+    }
+    default:
+      reason_1 = genericMsg(helpers, error.fields[0], error.fields[1], false);
+  }
+  if (error.tag === /* BadOneOf */
+  7) {
+    return reason_1;
+  } else {
+    return "Error at: `" + path + "`\n" + reason_1;
+  }
+}
+function Advanced_fromValue(helpers, decoder, value_1) {
+  const matchValue = decoder.Decode(helpers, value_1);
+  if (matchValue.tag === /* Error */
+  1) {
+    const error = matchValue.fields[0];
+    return FSharpResult$2_Error(errorToString(helpers, error[0], error[1]));
+  } else {
+    return FSharpResult$2_Ok(matchValue.fields[0]);
+  }
+}
+const string = {
+  Decode(helpers, value_1) {
+    return helpers.isString(value_1) ? FSharpResult$2_Ok(helpers.asString(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a string", value_1)]);
+  }
+};
+const char = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      const str = helpers.asString(value_1);
+      return str.length === 1 ? FSharpResult$2_Ok(str[0]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a single character string", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a char", value_1)]);
+    }
+  }
+};
+const guid = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = "00000000-0000-0000-0000-000000000000";
+      matchValue = [tryParse(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a guid", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a guid", value_1)]);
+    }
+  }
+};
+const unit = {
+  Decode(helpers, value_1) {
+    return helpers.isNullValue(value_1) ? FSharpResult$2_Ok(void 0) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("null", value_1)]);
+  }
+};
+const sbyte = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return -128 <= floatValue && floatValue <= 127 ? FSharpResult$2_Ok((floatValue + 128 & 255) - 128) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a sbyte", value_2, "Value was either too large or too small for a sbyte")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a sbyte", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, false, 8, new FSharpRef(() => outArg, (v) => {
+        outArg = v | 0;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a sbyte", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a sbyte", value_2)]);
+    }
+  }
+};
+const byte = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return 0 <= floatValue && floatValue <= 255 ? FSharpResult$2_Ok(floatValue & 255) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a byte", value_2, "Value was either too large or too small for a byte")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("a byte", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, true, 8, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a byte", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a byte", value_2)]);
+    }
+  }
+};
+const int16 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return -32768 <= floatValue && floatValue <= 32767 ? FSharpResult$2_Ok((floatValue + 32768 & 65535) - 32768) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int16", value_2, "Value was either too large or too small for an int16")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int16", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, false, 16, new FSharpRef(() => outArg, (v) => {
+        outArg = v | 0;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int16", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int16", value_2)]);
+    }
+  }
+};
+const uint16 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return 0 <= floatValue && floatValue <= 65535 ? FSharpResult$2_Ok(floatValue & 65535) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint16", value_2, "Value was either too large or too small for an uint16")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint16", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, true, 16, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint16", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint16", value_2)]);
+    }
+  }
+};
+const int = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return -2147483648 <= floatValue && floatValue <= 2147483647 ? FSharpResult$2_Ok(~~floatValue) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int", value_2, "Value was either too large or too small for an int")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, false, 32, new FSharpRef(() => outArg, (v) => {
+        outArg = v | 0;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int", value_2)]);
+    }
+  }
+};
+const uint32 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return 0 <= floatValue && floatValue <= 4294967295 ? FSharpResult$2_Ok(floatValue >>> 0) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint32", value_2, "Value was either too large or too small for an uint32")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint32", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$1(helpers.asString(value_2), 511, true, 32, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint32", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint32", value_2)]);
+    }
+  }
+};
+const int64 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return toFloat64(-9223372036854775808n) <= floatValue && floatValue <= toFloat64(9223372036854775807n) ? FSharpResult$2_Ok(toInt64(fromFloat64(floatValue))) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int64", value_2, "Value was either too large or too small for an int64")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an int64", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0n;
+      matchValue = [tryParse$2(helpers.asString(value_2), 511, false, 64, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int64", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an int64", value_2)]);
+    }
+  }
+};
+const uint64 = {
+  Decode(helpers, value_2) {
+    if (helpers.isNumber(value_2)) {
+      if (helpers.isIntegralValue(value_2)) {
+        const floatValue = helpers.asFloat(value_2);
+        return toFloat64(0n) <= floatValue && floatValue <= toFloat64(18446744073709551615n) ? FSharpResult$2_Ok(toUInt64(fromFloat64(floatValue))) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint64", value_2, "Value was either too large or too small for an uint64")]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitiveExtra("an uint64", value_2, "Value is not an integral value")]);
+      }
+    } else if (helpers.isString(value_2)) {
+      let matchValue;
+      let outArg = 0n;
+      matchValue = [tryParse$2(helpers.asString(value_2), 511, true, 64, new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint64", value_2)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an uint64", value_2)]);
+    }
+  }
+};
+const bigint = {
+  Decode(helpers, value_1) {
+    if (helpers.isNumber(value_1)) {
+      return FSharpResult$2_Ok(fromInt32(helpers.asInt(value_1)));
+    } else if (helpers.isString(value_1)) {
+      let parseResult;
+      let outArg = 0n;
+      parseResult = [tryParse$3(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return parseResult[0] ? FSharpResult$2_Ok(parseResult[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a bigint", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a bigint", value_1)]);
+    }
+  }
+};
+const bool = {
+  Decode(helpers, value_1) {
+    return helpers.isBoolean(value_1) ? FSharpResult$2_Ok(helpers.asBoolean(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a boolean", value_1)]);
+  }
+};
+const float = {
+  Decode(helpers, value_1) {
+    return helpers.isNumber(value_1) ? FSharpResult$2_Ok(helpers.asFloat(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a float", value_1)]);
+  }
+};
+const float32 = {
+  Decode(helpers, value_1) {
+    return helpers.isNumber(value_1) ? FSharpResult$2_Ok(helpers.asFloat32(value_1)) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a float32", value_1)]);
+  }
+};
+const decimal = {
+  Decode(helpers, value_1) {
+    if (helpers.isNumber(value_1)) {
+      return FSharpResult$2_Ok(new Big(helpers.asFloat(value_1)));
+    } else if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = new Big("0");
+      matchValue = [tryParse$4(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a decimal", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a decimal", value_1)]);
+    }
+  }
+};
+const datetimeUtc = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = minValue();
+      matchValue = [tryParse$5(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(toUniversalTime(matchValue[1])) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    }
+  }
+};
+const datetimeLocal = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = minValue();
+      matchValue = [tryParse$5(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    }
+  }
+};
+const datetimeOffset = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = minValue$1();
+      matchValue = [tryParse$6(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetimeoffset", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a datetime", value_1)]);
+    }
+  }
+};
+const timespan = {
+  Decode(helpers, value_1) {
+    if (helpers.isString(value_1)) {
+      let matchValue;
+      let outArg = 0;
+      matchValue = [tryParse$7(helpers.asString(value_1), new FSharpRef(() => outArg, (v) => {
+        outArg = v;
+      })), outArg];
+      return matchValue[0] ? FSharpResult$2_Ok(matchValue[1]) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a timespan", value_1)]);
+    } else {
+      return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a timespan", value_1)]);
+    }
+  }
+};
+function decodeMaybeNull(helpers, path, decoder, value_1) {
+  let tupledArg;
+  if (helpers.isNullValue(value_1)) {
+    return FSharpResult$2_Ok(void 0);
+  } else {
+    const matchValue = decoder.Decode(helpers, value_1);
+    if (matchValue.tag === /* Error */
+    1) {
+      return FSharpResult$2_Error((tupledArg = matchValue.fields[0], Helpers_prependPath(path, tupledArg[0], tupledArg[1])));
+    } else {
+      return FSharpResult$2_Ok(some(matchValue.fields[0]));
+    }
+  }
+}
+function optional(fieldName, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      return helpers.isObject(value_1) ? helpers.hasProperty(fieldName, value_1) ? decodeMaybeNull(helpers, "." + fieldName, decoder, helpers.getProperty(fieldName, value_1)) : FSharpResult$2_Ok(void 0) : FSharpResult$2_Error(["", ErrorReason$1_BadType("an object", value_1)]);
+    }
+  };
+}
+function badPathError(fieldNames, currentPath, value_1) {
+  return FSharpResult$2_Error(["." + defaultArg(currentPath, join(".", fieldNames)), ErrorReason$1_BadPath("an object with path `" + join(".", fieldNames) + "`", value_1, defaultArg(tryLast(fieldNames), ""))]);
+}
+function map2(ctor, d1, d2) {
+  return {
+    Decode(helpers, value_1) {
+      let er_1, v1, v2;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        return copyOfStruct_1.tag === /* Error */
+        1 ? (er_1 = copyOfStruct_1.fields[0], FSharpResult$2_Error(er_1)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], FSharpResult$2_Ok(ctor(v1, v2)));
+      }
+    }
+  };
+}
+function optionalAt(fieldNames, decoder) {
+  return {
+    Decode(helpers, firstValue) {
+      const _arg = fold((tupledArg, field_1) => {
+        const curPath = tupledArg[0];
+        const curValue = tupledArg[1];
+        const res = tupledArg[2];
+        if (res == null) {
+          if (helpers.isNullValue(curValue)) {
+            return [curPath, curValue, FSharpResult$2_Ok(void 0)];
+          } else if (helpers.isObject(curValue)) {
+            if (helpers.hasProperty(field_1, curValue)) {
+              return [curPath + "." + field_1, helpers.getProperty(field_1, curValue), void 0];
+            } else {
+              return [curPath, curValue, FSharpResult$2_Ok(void 0)];
+            }
+          } else {
+            return [curPath, curValue, FSharpResult$2_Error([curPath, ErrorReason$1_BadType("an object", curValue)])];
+          }
+        } else {
+          return [curPath, curValue, res];
+        }
+      }, ["", firstValue, void 0], fieldNames);
+      if (_arg[2] == null) {
+        const lastValue = _arg[1];
+        return helpers.isNullValue(lastValue) ? FSharpResult$2_Ok(void 0) : decodeMaybeNull(helpers, _arg[0], decoder, lastValue);
+      } else {
+        return value$1(_arg[2]);
+      }
+    }
+  };
+}
+function field(fieldName, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isObject(value_1)) {
+        if (helpers.hasProperty(fieldName, value_1)) {
+          const fieldValue = helpers.getProperty(fieldName, value_1);
+          const path = "." + fieldName;
+          return Result_MapError((tupledArg) => Helpers_prependPath(path, tupledArg[0], tupledArg[1]), decoder.Decode(helpers, fieldValue));
+        } else {
+          return FSharpResult$2_Error(["", ErrorReason$1_BadField("an object with a field named `" + fieldName + "`", value_1)]);
+        }
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadType("an object", value_1)]);
+      }
+    }
+  };
+}
+function at(fieldNames, decoder) {
+  return {
+    Decode(helpers, firstValue) {
+      const _arg = fold((tupledArg, field_1) => {
+        const curPath = tupledArg[0];
+        const curValue = tupledArg[1];
+        const res = tupledArg[2];
+        if (res == null) {
+          if (helpers.isNullValue(curValue)) {
+            return [curPath, curValue, badPathError(fieldNames, curPath, firstValue)];
+          } else if (helpers.isObject(curValue)) {
+            if (helpers.hasProperty(field_1, curValue)) {
+              return [curPath + "." + field_1, helpers.getProperty(field_1, curValue), void 0];
+            } else {
+              return [curPath, curValue, badPathError(fieldNames, void 0, firstValue)];
+            }
+          } else {
+            return [curPath, curValue, FSharpResult$2_Error([curPath, ErrorReason$1_BadType("an object", curValue)])];
+          }
+        } else {
+          return [curPath, curValue, res];
+        }
+      }, ["", firstValue, void 0], fieldNames);
+      return _arg[2] == null ? Result_MapError((tupledArg_1) => Helpers_prependPath(_arg[0], tupledArg_1[0], tupledArg_1[1]), decoder.Decode(helpers, _arg[1])) : value$1(_arg[2]);
+    }
+  };
+}
+function index(requestedIndex, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isArray(value_1)) {
+        const vArray = helpers.asArray(value_1);
+        const path = ".[" + int32ToString(requestedIndex) + "]";
+        return requestedIndex < vArray.length ? Result_MapError((tupledArg) => Helpers_prependPath(path, tupledArg[0], tupledArg[1]), decoder.Decode(helpers, item(requestedIndex, vArray))) : FSharpResult$2_Error([path, ErrorReason$1_TooSmallArray("a longer array. Need index `" + int32ToString(requestedIndex) + "` but there are only `" + int32ToString(vArray.length) + "` entries", value_1)]);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an array", value_1)]);
+      }
+    }
+  };
+}
+function list(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      let tupledArg;
+      if (helpers.isArray(value_1)) {
+        const tokens = helpers.asArray(value_1);
+        let i = 0;
+        let result = empty();
+        let error = void 0;
+        while (i < tokens.length && error == null) {
+          const value_2 = item(i, tokens);
+          const matchValue = decoder.Decode(helpers, value_2);
+          if (matchValue.tag === /* Error */
+          1) {
+            const x = (tupledArg = matchValue.fields[0], Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1]));
+            error = x;
+          } else {
+            const value_3 = matchValue.fields[0];
+            result = append(result, singleton(value_3));
+          }
+          i = i + 1 | 0;
+        }
+        return error == null ? FSharpResult$2_Ok(result) : FSharpResult$2_Error(value$1(error));
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a list", value_1)]);
+      }
+    }
+  };
+}
+function resizeArray(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      let tupledArg;
+      if (helpers.isArray(value_1)) {
+        const tokens = helpers.asArray(value_1);
+        let i = 0;
+        const result = [];
+        let error = void 0;
+        while (i < tokens.length && error == null) {
+          const value_2 = item(i, tokens);
+          const matchValue = decoder.Decode(helpers, value_2);
+          if (matchValue.tag === /* Error */
+          1) {
+            const er = matchValue.fields[0];
+            error = (tupledArg = er, Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1]));
+          } else {
+            const value_3 = matchValue.fields[0];
+            void result.push(value_3);
+          }
+          i = i + 1 | 0;
+        }
+        return error == null ? FSharpResult$2_Ok(Array.from(result)) : FSharpResult$2_Error(value$1(error));
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a ResizeArray", value_1)]);
+      }
+    }
+  };
+}
+function seq(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isArray(value_1)) {
+        let i = -1;
+        return Result_Map(reverse, fold$1((acc, value_2) => {
+          let tupledArg;
+          i = i + 1 | 0;
+          if (acc.tag === /* Ok */
+          0) {
+            const acc_1 = acc.fields[0];
+            const matchValue = decoder.Decode(helpers, value_2);
+            if (matchValue.tag === /* Ok */
+            0) {
+              return FSharpResult$2_Ok(append$1([matchValue.fields[0]], acc_1));
+            } else {
+              return FSharpResult$2_Error((tupledArg = matchValue.fields[0], Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1])));
+            }
+          } else {
+            return acc;
+          }
+        }, FSharpResult$2_Ok([]), helpers.asArray(value_1)));
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("a seq", value_1)]);
+      }
+    }
+  };
+}
+function array(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      if (helpers.isArray(value_1)) {
+        let i = -1;
+        const tokens = helpers.asArray(value_1);
+        return fold$1((acc, value_2) => {
+          let tupledArg;
+          i = i + 1 | 0;
+          if (acc.tag === /* Ok */
+          0) {
+            const acc_1 = acc.fields[0];
+            const matchValue = decoder.Decode(helpers, value_2);
+            if (matchValue.tag === /* Ok */
+            0) {
+              const value_3 = matchValue.fields[0];
+              setItem(acc_1, i, value_3);
+              return FSharpResult$2_Ok(acc_1);
+            } else {
+              return FSharpResult$2_Error((tupledArg = matchValue.fields[0], Helpers_prependPath(".[" + int32ToString(i) + "]", tupledArg[0], tupledArg[1])));
+            }
+          } else {
+            return acc;
+          }
+        }, FSharpResult$2_Ok(fill(new Array(tokens.length), 0, tokens.length, null)), tokens);
+      } else {
+        return FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an array", value_1)]);
+      }
+    }
+  };
+}
+const keys = {
+  Decode(helpers, value_1) {
+    return helpers.isObject(value_1) ? FSharpResult$2_Ok(ofSeq(helpers.getProperties(value_1))) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("an object", value_1)]);
+  }
+};
+function keyValuePairs(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      const matchValue = keys.Decode(helpers, value_1);
+      return matchValue.tag === /* Error */
+      1 ? FSharpResult$2_Error(matchValue.fields[0]) : Result_Map(reverse$1, fold((acc, prop) => {
+        if (acc.tag === /* Ok */
+        0) {
+          const acc_1 = acc.fields[0];
+          const fieldValue = helpers.getProperty(prop, value_1);
+          const matchValue_1 = decoder.Decode(helpers, fieldValue);
+          if (matchValue_1.tag === /* Ok */
+          0) {
+            return FSharpResult$2_Ok(cons([prop, matchValue_1.fields[0]], acc_1));
+          } else {
+            return FSharpResult$2_Error(matchValue_1.fields[0]);
+          }
+        } else {
+          return acc;
+        }
+      }, FSharpResult$2_Ok(empty()), matchValue.fields[0]));
+    }
+  };
+}
+function oneOf(decoders) {
+  return {
+    Decode(helpers, value_1) {
+      const runner = (decoders_1_mut, errors_mut) => {
+        runner:
+          while (true) {
+            const decoders_1 = decoders_1_mut, errors = errors_mut;
+            if (isEmpty(decoders_1)) {
+              return FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]);
+            } else {
+              const matchValue = head(decoders_1).Decode(helpers, value_1);
+              if (matchValue.tag === /* Error */
+              1) {
+                decoders_1_mut = tail(decoders_1);
+                errors_mut = append(errors, singleton(matchValue.fields[0]));
+                continue runner;
+              } else {
+                return FSharpResult$2_Ok(matchValue.fields[0]);
+              }
+            }
+            break;
+          }
+      };
+      return runner(decoders, empty());
+    }
+  };
+}
+function nil(output) {
+  return {
+    Decode(helpers, value_1) {
+      return helpers.isNullValue(value_1) ? FSharpResult$2_Ok(output) : FSharpResult$2_Error(["", ErrorReason$1_BadPrimitive("null", value_1)]);
+    }
+  };
+}
+function value(_arg, v) {
+  return FSharpResult$2_Ok(v);
+}
+function succeed(output) {
+  return {
+    Decode(_arg, _arg_1) {
+      return FSharpResult$2_Ok(output);
+    }
+  };
+}
+function fail(msg) {
+  return {
+    Decode(_arg, _arg_1) {
+      return FSharpResult$2_Error(["", ErrorReason$1_FailMessage(msg)]);
+    }
+  };
+}
+function andThen(cb, decoder) {
+  return {
+    Decode(helpers, value_1) {
+      const matchValue = decoder.Decode(helpers, value_1);
+      if (matchValue.tag === /* Ok */
+      0) {
+        const result = matchValue.fields[0];
+        return cb(result).Decode(helpers, value_1);
+      } else {
+        return FSharpResult$2_Error(matchValue.fields[0]);
+      }
+    }
+  };
+}
+function all(decoders) {
+  return {
+    Decode(helpers, value_1) {
+      const runner = (decoders_1_mut, values_mut) => {
+        runner:
+          while (true) {
+            const decoders_1 = decoders_1_mut, values = values_mut;
+            if (isEmpty(decoders_1)) {
+              return FSharpResult$2_Ok(values);
+            } else {
+              const matchValue = head(decoders_1).Decode(helpers, value_1);
+              if (matchValue.tag === /* Error */
+              1) {
+                return FSharpResult$2_Error(matchValue.fields[0]);
+              } else {
+                decoders_1_mut = tail(decoders_1);
+                values_mut = append(values, singleton(matchValue.fields[0]));
+                continue runner;
+              }
+            }
+            break;
+          }
+      };
+      return runner(decoders, empty());
+    }
+  };
+}
+function map(ctor, d1) {
+  return {
+    Decode(helpers, value_1) {
+      const matchValue = d1.Decode(helpers, value_1);
+      return matchValue.tag === /* Error */
+      1 ? FSharpResult$2_Error(matchValue.fields[0]) : FSharpResult$2_Ok(ctor(matchValue.fields[0]));
+    }
+  };
+}
+function map3(ctor, d1, d2, d3) {
+  return {
+    Decode(helpers, value_1) {
+      let er_2, v1, v2, v3;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          return copyOfStruct_2.tag === /* Error */
+          1 ? (er_2 = copyOfStruct_2.fields[0], FSharpResult$2_Error(er_2)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3)));
+        }
+      }
+    }
+  };
+}
+function map4(ctor, d1, d2, d3, d4) {
+  return {
+    Decode(helpers, value_1) {
+      let er_3, v1, v2, v3, v4;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            return copyOfStruct_3.tag === /* Error */
+            1 ? (er_3 = copyOfStruct_3.fields[0], FSharpResult$2_Error(er_3)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4)));
+          }
+        }
+      }
+    }
+  };
+}
+function map5(ctor, d1, d2, d3, d4, d5) {
+  return {
+    Decode(helpers, value_1) {
+      let er_4, v1, v2, v3, v4, v5;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              return copyOfStruct_4.tag === /* Error */
+              1 ? (er_4 = copyOfStruct_4.fields[0], FSharpResult$2_Error(er_4)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5)));
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function map6(ctor, d1, d2, d3, d4, d5, d6) {
+  return {
+    Decode(helpers, value_1) {
+      let er_5, v1, v2, v3, v4, v5, v6;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const matchValue_5 = d6.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              if (copyOfStruct_4.tag === /* Error */
+              1) {
+                const er_4 = copyOfStruct_4.fields[0];
+                return FSharpResult$2_Error(er_4);
+              } else {
+                const copyOfStruct_5 = matchValue_5;
+                return copyOfStruct_5.tag === /* Error */
+                1 ? (er_5 = copyOfStruct_5.fields[0], FSharpResult$2_Error(er_5)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], v6 = copyOfStruct_5.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5, v6)));
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function map7(ctor, d1, d2, d3, d4, d5, d6, d7) {
+  return {
+    Decode(helpers, value_1) {
+      let er_6, v1, v2, v3, v4, v5, v6, v7;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const matchValue_5 = d6.Decode(helpers, value_1);
+      const matchValue_6 = d7.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              if (copyOfStruct_4.tag === /* Error */
+              1) {
+                const er_4 = copyOfStruct_4.fields[0];
+                return FSharpResult$2_Error(er_4);
+              } else {
+                const copyOfStruct_5 = matchValue_5;
+                if (copyOfStruct_5.tag === /* Error */
+                1) {
+                  const er_5 = copyOfStruct_5.fields[0];
+                  return FSharpResult$2_Error(er_5);
+                } else {
+                  const copyOfStruct_6 = matchValue_6;
+                  return copyOfStruct_6.tag === /* Error */
+                  1 ? (er_6 = copyOfStruct_6.fields[0], FSharpResult$2_Error(er_6)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], v6 = copyOfStruct_5.fields[0], v7 = copyOfStruct_6.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5, v6, v7)));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function map8(ctor, d1, d2, d3, d4, d5, d6, d7, d8) {
+  return {
+    Decode(helpers, value_1) {
+      let er_7, v1, v2, v3, v4, v5, v6, v7, v8;
+      const matchValue = d1.Decode(helpers, value_1);
+      const matchValue_1 = d2.Decode(helpers, value_1);
+      const matchValue_2 = d3.Decode(helpers, value_1);
+      const matchValue_3 = d4.Decode(helpers, value_1);
+      const matchValue_4 = d5.Decode(helpers, value_1);
+      const matchValue_5 = d6.Decode(helpers, value_1);
+      const matchValue_6 = d7.Decode(helpers, value_1);
+      const matchValue_7 = d8.Decode(helpers, value_1);
+      const copyOfStruct = matchValue;
+      if (copyOfStruct.tag === /* Error */
+      1) {
+        const er = copyOfStruct.fields[0];
+        return FSharpResult$2_Error(er);
+      } else {
+        const copyOfStruct_1 = matchValue_1;
+        if (copyOfStruct_1.tag === /* Error */
+        1) {
+          const er_1 = copyOfStruct_1.fields[0];
+          return FSharpResult$2_Error(er_1);
+        } else {
+          const copyOfStruct_2 = matchValue_2;
+          if (copyOfStruct_2.tag === /* Error */
+          1) {
+            const er_2 = copyOfStruct_2.fields[0];
+            return FSharpResult$2_Error(er_2);
+          } else {
+            const copyOfStruct_3 = matchValue_3;
+            if (copyOfStruct_3.tag === /* Error */
+            1) {
+              const er_3 = copyOfStruct_3.fields[0];
+              return FSharpResult$2_Error(er_3);
+            } else {
+              const copyOfStruct_4 = matchValue_4;
+              if (copyOfStruct_4.tag === /* Error */
+              1) {
+                const er_4 = copyOfStruct_4.fields[0];
+                return FSharpResult$2_Error(er_4);
+              } else {
+                const copyOfStruct_5 = matchValue_5;
+                if (copyOfStruct_5.tag === /* Error */
+                1) {
+                  const er_5 = copyOfStruct_5.fields[0];
+                  return FSharpResult$2_Error(er_5);
+                } else {
+                  const copyOfStruct_6 = matchValue_6;
+                  if (copyOfStruct_6.tag === /* Error */
+                  1) {
+                    const er_6 = copyOfStruct_6.fields[0];
+                    return FSharpResult$2_Error(er_6);
+                  } else {
+                    const copyOfStruct_7 = matchValue_7;
+                    return copyOfStruct_7.tag === /* Error */
+                    1 ? (er_7 = copyOfStruct_7.fields[0], FSharpResult$2_Error(er_7)) : (v1 = copyOfStruct.fields[0], v2 = copyOfStruct_1.fields[0], v3 = copyOfStruct_2.fields[0], v4 = copyOfStruct_3.fields[0], v5 = copyOfStruct_4.fields[0], v6 = copyOfStruct_5.fields[0], v7 = copyOfStruct_6.fields[0], v8 = copyOfStruct_7.fields[0], FSharpResult$2_Ok(ctor(v1, v2, v3, v4, v5, v6, v7, v8)));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function lossyOption(decoder) {
+  return {
+    Decode(helpers, value_1) {
+      return helpers.isNullValue(value_1) ? FSharpResult$2_Ok(void 0) : Result_Map(some, decoder.Decode(helpers, value_1));
+    }
+  };
+}
+function losslessOption(decoder) {
+  return andThen((typeName) => {
+    if (typeName === "option") {
+      return andThen((state) => {
+        switch (state) {
+          case "none":
+            return succeed(void 0);
+          case "some":
+            return map(some, field("$value", decoder));
+          default:
+            return fail("Expecting a state field with value 'none' or 'some' but got " + state);
+        }
+      }, field("$case", string));
+    } else {
+      return fail("Expecting an Option type but got " + typeName);
+    }
+  }, field("$type", string));
+}
+function andMap() {
+  return (d) => (d_1) => map2((arg, func) => func(arg), d, d_1);
+}
+function unwrapWith(errors, helpers, decoder, value_1) {
+  const matchValue = decoder.Decode(helpers, value_1);
+  if (matchValue.tag === /* Error */
+  1) {
+    const er = matchValue.fields[0];
+    void errors.push(er);
+    return defaultOf();
+  } else {
+    return matchValue.fields[0];
+  }
+}
+class Getters$2 {
+  constructor(helpers, value_1) {
+    let _this, _this_1;
+    this.errors = [];
+    this.required = (_this = this, {
+      Field(fieldName, decoder) {
+        return unwrapWith(_this.errors, helpers, field(fieldName, decoder), value_1);
+      },
+      At(fieldNames, decoder_1) {
+        return unwrapWith(_this.errors, helpers, at(fieldNames, decoder_1), value_1);
+      },
+      Raw(decoder_2) {
+        return unwrapWith(_this.errors, helpers, decoder_2, value_1);
+      }
+    });
+    this.optional = (_this_1 = this, {
+      Field(fieldName_1, decoder_3) {
+        return unwrapWith(_this_1.errors, helpers, optional(fieldName_1, decoder_3), value_1);
+      },
+      At(fieldNames_1, decoder_4) {
+        return unwrapWith(_this_1.errors, helpers, optionalAt(fieldNames_1, decoder_4), value_1);
+      },
+      Raw(decoder_5) {
+        const matchValue = decoder_5.Decode(helpers, value_1);
+        if (matchValue.tag === /* Error */
+        1) {
+          const reason = matchValue.fields[0][1];
+          const error = matchValue.fields[0];
+          let matchResult, v_1;
+          switch (reason.tag) {
+            case /* BadField */
+            3:
+            case /* BadPath */
+            4: {
+              matchResult = 1;
+              break;
+            }
+            case /* TooSmallArray */
+            5:
+            case /* FailMessage */
+            6:
+            case /* BadOneOf */
+            7: {
+              matchResult = 2;
+              break;
+            }
+            case /* BadPrimitiveExtra */
+            1: {
+              matchResult = 0;
+              v_1 = reason.fields[1];
+              break;
+            }
+            case /* BadType */
+            2: {
+              matchResult = 0;
+              v_1 = reason.fields[1];
+              break;
+            }
+            default: {
+              matchResult = 0;
+              v_1 = reason.fields[1];
+            }
+          }
+          switch (matchResult) {
+            case 0:
+              if (helpers.isNullValue(v_1)) {
+                return void 0;
+              } else {
+                void _this_1.errors.push(error);
+                return defaultOf();
+              }
+            case 1:
+              return void 0;
+            default: {
+              void _this_1.errors.push(error);
+              return defaultOf();
+            }
+          }
+        } else {
+          return some(matchValue.fields[0]);
+        }
+      }
+    });
+  }
+  get Required() {
+    const __ = this;
+    return __.required;
+  }
+  get Optional() {
+    const __ = this;
+    return __.optional;
+  }
+}
+function Getters$2_$reflection(gen0, gen1) {
+  return class_type("Thoth.Json.Core.Decode.Getters`2", [gen0, gen1], Getters$2);
+}
+function Getters$2_$ctor_Z4BE6C149(helpers, value_1) {
+  return new Getters$2(helpers, value_1);
+}
+function Getters$2__get_Errors(__) {
+  return toList(__.errors);
+}
+function object(builder) {
+  return {
+    Decode(helpers, value_1) {
+      const getters = Getters$2_$ctor_Z4BE6C149(helpers, value_1);
+      const result = builder(getters);
+      const matchValue = Getters$2__get_Errors(getters);
+      if (!isEmpty(matchValue)) {
+        const errors = matchValue;
+        return length(errors) > 1 ? FSharpResult$2_Error(["", ErrorReason$1_BadOneOf(errors)]) : FSharpResult$2_Error(head(matchValue));
+      } else {
+        return FSharpResult$2_Ok(result);
+      }
+    }
+  };
+}
+function tuple2(decoder1, decoder2) {
+  return andThen((v1) => andThen((v2) => succeed([v1, v2]), index(1, decoder2)), index(0, decoder1));
+}
+function tuple3(decoder1, decoder2, decoder3) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => succeed([v1, v2, v3]), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple4(decoder1, decoder2, decoder3, decoder4) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => succeed([v1, v2, v3, v4]), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => succeed([v1, v2, v3, v4, v5]), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => andThen((v6) => succeed([v1, v2, v3, v4, v5, v6]), index(5, decoder6)), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple7(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => andThen((v6) => andThen((v7) => succeed([v1, v2, v3, v4, v5, v6, v7]), index(6, decoder7)), index(5, decoder6)), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function tuple8(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7, decoder8) {
+  return andThen((v1) => andThen((v2) => andThen((v3) => andThen((v4) => andThen((v5) => andThen((v6) => andThen((v7) => andThen((v8) => succeed([v1, v2, v3, v4, v5, v6, v7, v8]), index(7, decoder8)), index(6, decoder7)), index(5, decoder6)), index(4, decoder5)), index(3, decoder4)), index(2, decoder3)), index(1, decoder2)), index(0, decoder1));
+}
+function dict(decoder) {
+  return map((elements) => ofList(elements, {
+    Compare: comparePrimitives
+  }), keyValuePairs(decoder));
+}
+function map$0027(keyDecoder, valueDecoder) {
+  return map((elements) => ofSeq$1(elements, {
+    Compare: compare
+  }), array(tuple2(keyDecoder, valueDecoder)));
+}
+
+export { Advanced_fromValue, Getters$2, Getters$2_$ctor_Z4BE6C149, Getters$2_$reflection, Getters$2__get_Errors, Helpers_prependPath, all, andMap, andThen, array, at, bigint, bool, byte, char, datetimeLocal, datetimeOffset, datetimeUtc, decimal, dict, errorToString, fail, field, float, float32, guid, index, int, int16, int64, keyValuePairs, keys, list, losslessOption, lossyOption, map, map$0027, map2, map3, map4, map5, map6, map7, map8, nil, object, oneOf, optional, optionalAt, resizeArray, sbyte, seq, string, succeed, timespan, tuple2, tuple3, tuple4, tuple5, tuple6, tuple7, tuple8, uint16, uint32, uint64, unit, value };