@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Encode.fs.js

@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Auto () {
+        return Auto;
+    },
+    get Auto_$reflection () {
+        return Auto_$reflection;
+    },
+    get Auto_generateBoxedEncoderCached_437914C6 () {
+        return Auto_generateBoxedEncoderCached_437914C6;
+    },
+    get Auto_generateBoxedEncoder_437914C6 () {
+        return Auto_generateBoxedEncoder_437914C6;
+    },
+    get Enum_byte () {
+        return Enum_byte;
+    },
+    get Enum_int () {
+        return Enum_int;
+    },
+    get Enum_int16 () {
+        return Enum_int16;
+    },
+    get Enum_sbyte () {
+        return Enum_sbyte;
+    },
+    get Enum_uint16 () {
+        return Enum_uint16;
+    },
+    get Enum_uint32 () {
+        return Enum_uint32;
+    },
+    get bigint () {
+        return bigint;
+    },
+    get datetime () {
+        return datetime;
+    },
+    get datetimeOffset () {
+        return datetimeOffset;
+    },
+    get decimal () {
+        return decimal;
+    },
+    get dict () {
+        return dict;
+    },
+    get encode () {
+        return encode;
+    },
+    get guid () {
+        return guid;
+    },
+    get int64 () {
+        return int64;
+    },
+    get list () {
+        return list;
+    },
+    get map () {
+        return map;
+    },
+    get nil () {
+        return nil;
+    },
+    get object () {
+        return object;
+    },
+    get option () {
+        return option;
+    },
+    get seq () {
+        return seq;
+    },
+    get timespan () {
+        return timespan;
+    },
+    get toString () {
+        return toString;
+    },
+    get tuple2 () {
+        return tuple2;
+    },
+    get tuple3 () {
+        return tuple3;
+    },
+    get tuple4 () {
+        return tuple4;
+    },
+    get tuple5 () {
+        return tuple5;
+    },
+    get tuple6 () {
+        return tuple6;
+    },
+    get tuple7 () {
+        return tuple7;
+    },
+    get tuple8 () {
+        return tuple8;
+    },
+    get uint64 () {
+        return uint64;
+    },
+    get unit () {
+        return unit;
+    }
+});
+const _Decimal = require("@fable-org/fable-library-js/Decimal.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _BigInt = require("@fable-org/fable-library-js/BigInt.js");
+const _Date = require("@fable-org/fable-library-js/Date.js");
+const _TimeSpan = require("@fable-org/fable-library-js/TimeSpan.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _Array = require("@fable-org/fable-library-js/Array.js");
+const _Typesfs = require("./Types.fs.js");
+const _Seq = require("@fable-org/fable-library-js/Seq.js");
+const _String = require("@fable-org/fable-library-js/String.js");
+function guid(value) {
+    return value;
+}
+function decimal(value) {
+    return (0, _Decimal.toString)(value);
+}
+const nil = (0, _Util.defaultOf)();
+function object(values) {
+    const o = {};
+    const enumerator = (0, _Util.getEnumerator)(values);
+    try {
+        while(enumerator["System.Collections.IEnumerator.MoveNext"]()){
+            const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            o[forLoopVar[0]] = forLoopVar[1];
+        }
+    } finally{
+        (0, _Util.disposeSafe)(enumerator);
+    }
+    return o;
+}
+function list(values) {
+    return Array.from(values);
+}
+function seq(values) {
+    return Array.from(values);
+}
+function dict(values) {
+    return object((0, _Map.toList)(values));
+}
+function bigint(value) {
+    return (0, _BigInt.toString)(value);
+}
+function datetimeOffset(value) {
+    return (0, _Date.toString)(value, "O", {});
+}
+function timespan(value) {
+    return (0, _TimeSpan.toString)(value);
+}
+function int64(value) {
+    return String(value);
+}
+function uint64(value) {
+    return String(value);
+}
+function unit() {
+    return (0, _Util.defaultOf)();
+}
+function tuple2(enc1, enc2, v1, v2) {
+    return [
+        enc1(v1),
+        enc2(v2)
+    ];
+}
+function tuple3(enc1, enc2, enc3, v1, v2, v3) {
+    return [
+        enc1(v1),
+        enc2(v2),
+        enc3(v3)
+    ];
+}
+function tuple4(enc1, enc2, enc3, enc4, v1, v2, v3, v4) {
+    return [
+        enc1(v1),
+        enc2(v2),
+        enc3(v3),
+        enc4(v4)
+    ];
+}
+function tuple5(enc1, enc2, enc3, enc4, enc5, v1, v2, v3, v4, v5) {
+    return [
+        enc1(v1),
+        enc2(v2),
+        enc3(v3),
+        enc4(v4),
+        enc5(v5)
+    ];
+}
+function tuple6(enc1, enc2, enc3, enc4, enc5, enc6, v1, v2, v3, v4, v5, v6) {
+    return [
+        enc1(v1),
+        enc2(v2),
+        enc3(v3),
+        enc4(v4),
+        enc5(v5),
+        enc6(v6)
+    ];
+}
+function tuple7(enc1, enc2, enc3, enc4, enc5, enc6, enc7, v1, v2, v3, v4, v5, v6, v7) {
+    return [
+        enc1(v1),
+        enc2(v2),
+        enc3(v3),
+        enc4(v4),
+        enc5(v5),
+        enc6(v6),
+        enc7(v7)
+    ];
+}
+function tuple8(enc1, enc2, enc3, enc4, enc5, enc6, enc7, enc8, v1, v2, v3, v4, v5, v6, v7, v8) {
+    return [
+        enc1(v1),
+        enc2(v2),
+        enc3(v3),
+        enc4(v4),
+        enc5(v5),
+        enc6(v6),
+        enc7(v7),
+        enc8(v8)
+    ];
+}
+function map(keyEncoder, valueEncoder, values) {
+    return list((0, _List.map)((tupledArg)=>tuple2(keyEncoder, valueEncoder, tupledArg[0], tupledArg[1]), (0, _Map.toList)(values)));
+}
+function Enum_byte(value) {
+    return value;
+}
+function Enum_sbyte(value) {
+    return value;
+}
+function Enum_int16(value) {
+    return value;
+}
+function Enum_uint16(value) {
+    return value;
+}
+function Enum_int(value) {
+    return value;
+}
+function Enum_uint32(value) {
+    return value;
+}
+function datetime(value) {
+    return (0, _Date.toString)(value, "O", {});
+}
+function toString(space, value) {
+    return JSON.stringify(value, undefined, (0, _Option.some)(space));
+}
+function option(encoder) {
+    return (arg)=>(0, _Option.defaultArgWith)((0, _Option.map)(encoder, arg), ()=>nil);
+}
+function autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t) {
+    let arg;
+    const encoderRef = new _Types.FSharpRef((0, _Util.defaultOf)());
+    let extra_1;
+    const matchValue = (0, _Reflection.fullName)(t);
+    extra_1 = matchValue === "" ? extra : (0, _Map.add)(matchValue, encoderRef, extra);
+    let encoder;
+    if ((0, _Reflection.isRecord)(t, true)) {
+        const setters = (0, _Array.map)((fi)=>{
+            const targetKey = (0, _Typesfs.Util_Casing_convert)(caseStrategy, (0, _Reflection.name)(fi));
+            const encode_1 = autoEncoder(extra_1, caseStrategy, skipNullField, fi[1]);
+            return (source)=>(target)=>{
+                    const value = (0, _Reflection.getRecordField)(source, fi);
+                    if (!skipNullField ? true : skipNullField && !(value == null)) {
+                        target[targetKey] = encode_1(value);
+                    }
+                    return target;
+                };
+        }, (0, _Reflection.getRecordElements)(t, true));
+        encoder = (source_1)=>(0, _Seq.fold)((target_1, set$)=>set$(source_1)(target_1), {}, setters);
+    } else if ((0, _Reflection.isUnion)(t, true)) {
+        encoder = (value_1)=>{
+            const patternInput = (0, _Reflection.getUnionFields)(value_1, t, true);
+            const info = patternInput[0];
+            const fields = patternInput[1];
+            const matchValue_1 = fields.length | 0;
+            if (matchValue_1 === 0) {
+                return (0, _Reflection.name)(info);
+            } else {
+                const len = matchValue_1 | 0;
+                const fieldTypes = (0, _Reflection.getUnionCaseFields)(info);
+                const target_2 = (0, _Array.fill)(new Array(len + 1), 0, len + 1, null);
+                (0, _Array.setItem)(target_2, 0, (0, _Reflection.name)(info));
+                for(let i = 1; i <= len; i++){
+                    const encode_2 = autoEncoder(extra_1, caseStrategy, skipNullField, (0, _Array.item)(i - 1, fieldTypes)[1]);
+                    (0, _Array.setItem)(target_2, i, encode_2((0, _Array.item)(i - 1, fields)));
+                }
+                return target_2;
+            }
+        };
+    } else {
+        throw new Error((arg = (0, _Reflection.fullName)(t), (0, _String.toText)((0, _String.printf)("Cannot generate auto encoder for %s. Please pass an extra encoder.\n\nDocumentation available at: https://thoth-org.github.io/Thoth.Json/documentation/auto/extra-coders.html#ready-to-use-extra-coders"))(arg)));
+    }
+    encoderRef.contents = encoder;
+    return encoder;
+}
+function autoEncoder(extra, caseStrategy, skipNullField, t) {
+    const fullname = (0, _Reflection.fullName)(t);
+    const matchValue = (0, _Map.tryFind)(fullname, extra);
+    if (matchValue == null) {
+        if ((0, _Reflection.isArray)(t)) {
+            const encoder = autoEncoder(extra, caseStrategy, skipNullField, (0, _Reflection.getElementType)(t));
+            return (value)=>seq((0, _Seq.map)(encoder, value));
+        } else if ((0, _Reflection.isEnum)(t)) {
+            const enumType = (0, _Reflection.fullName)((0, _Reflection.getEnumUnderlyingType)(t));
+            switch(enumType){
+                case "System.SByte":
+                    return (value_1)=>value_1;
+                case "System.Byte":
+                    return (value_3)=>value_3;
+                case "System.Int16":
+                    return (value_5)=>value_5;
+                case "System.UInt16":
+                    return (value_7)=>value_7;
+                case "System.Int32":
+                    return (value_9)=>value_9;
+                case "System.UInt32":
+                    return (value_11)=>value_11;
+                default:
+                    {
+                        const arg = (0, _Reflection.fullName)(t);
+                        const clo_1 = (0, _String.toFail)((0, _String.printf)("Cannot generate auto encoder for %s.\nThoth.Json.Net only support the following enum types:\n- sbyte\n- byte\n- int16\n- uint16\n- int\n- uint32\n\nIf you can\'t use one of these types, please pass an extra encoder.\n\nDocumentation available at: https://thoth-org.github.io/Thoth.Json/documentation/auto/extra-coders.html#ready-to-use-extra-coders\n                    "))(arg);
+                        return clo_1;
+                    }
+            }
+        } else if ((0, _Reflection.isGenericType)(t)) {
+            if ((0, _Reflection.isTuple)(t)) {
+                const encoders = (0, _Array.map)((t_2)=>autoEncoder(extra, caseStrategy, skipNullField, t_2), (0, _Reflection.getTupleElements)(t));
+                return (value_13)=>seq((0, _Seq.mapIndexed)((i, x)=>(0, _Array.item)(i, encoders)(x), (0, _Reflection.getTupleFields)(value_13)));
+            } else {
+                const fullname_1 = (0, _Reflection.fullName)((0, _Reflection.getGenericTypeDefinition)(t));
+                if (fullname_1 === "Microsoft.FSharp.Core.FSharpOption`1[System.Object]") {
+                    const encoder_2 = new _Util.Lazy(()=>option(autoEncoder(extra, caseStrategy, skipNullField, (0, _Array.item)(0, (0, _Reflection.getGenerics)(t)))));
+                    return (value_14)=>{
+                        if (value_14 == null) {
+                            return nil;
+                        } else {
+                            return encoder_2.Value(value_14);
+                        }
+                    };
+                } else if ((fullname_1 === "Microsoft.FSharp.Collections.FSharpList`1[System.Object]" ? true : fullname_1 === "Microsoft.FSharp.Collections.FSharpSet`1[System.Object]") ? true : fullname_1 === "System.Collections.Generic.IEnumerable`1[System.Object]") {
+                    const encoder_3 = autoEncoder(extra, caseStrategy, skipNullField, (0, _Array.item)(0, (0, _Reflection.getGenerics)(t)));
+                    return (value_15)=>seq((0, _Seq.map)(encoder_3, value_15));
+                } else if (fullname_1 === "Microsoft.FSharp.Collections.FSharpMap`2[System.Object,System.Object]") {
+                    const keyType = (0, _Array.item)(0, (0, _Reflection.getGenerics)(t));
+                    const valueEncoder = autoEncoder(extra, caseStrategy, skipNullField, (0, _Array.item)(1, (0, _Reflection.getGenerics)(t)));
+                    if ((0, _Reflection.fullName)(keyType) === "System.String" ? true : (0, _Reflection.fullName)(keyType) === "System.Guid") {
+                        return (value_16)=>(0, _Seq.fold)((target, _arg)=>{
+                                const activePatternResult = _arg;
+                                target[activePatternResult[0]] = valueEncoder(activePatternResult[1]);
+                                return target;
+                            }, {}, value_16);
+                    } else {
+                        let keyEncoder;
+                        const clo_2 = autoEncoder(extra, caseStrategy, skipNullField, keyType);
+                        keyEncoder = clo_2;
+                        return (value_17)=>seq((0, _Seq.map)((_arg_1)=>{
+                                const activePatternResult_1 = _arg_1;
+                                return [
+                                    keyEncoder(activePatternResult_1[0]),
+                                    valueEncoder(activePatternResult_1[1])
+                                ];
+                            }, value_17));
+                    }
+                } else {
+                    return autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t);
+                }
+            }
+        } else {
+            switch(fullname){
+                case "System.Boolean":
+                    return (value_18)=>value_18;
+                case "Microsoft.FSharp.Core.Unit":
+                    return unit;
+                case "System.String":
+                    return (value_20)=>value_20;
+                case "System.Char":
+                    return (value_22)=>value_22;
+                case "System.SByte":
+                    return (value_24)=>value_24;
+                case "System.Byte":
+                    return (value_26)=>value_26;
+                case "System.Int16":
+                    return (value_28)=>value_28;
+                case "System.UInt16":
+                    return (value_30)=>value_30;
+                case "System.Int32":
+                    return (value_32)=>value_32;
+                case "System.UInt32":
+                    return (value_34)=>value_34;
+                case "System.Double":
+                    return (value_36)=>value_36;
+                case "System.Single":
+                    return (value_38)=>value_38;
+                case "System.DateTime":
+                    return datetime;
+                case "System.DateTimeOffset":
+                    return datetimeOffset;
+                case "System.TimeSpan":
+                    return timespan;
+                case "System.Guid":
+                    return guid;
+                case "System.Object":
+                    return (x_1)=>x_1;
+                default:
+                    return autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t);
+            }
+        }
+    } else {
+        const encoderRef = (0, _Option.value)(matchValue);
+        return (v)=>encoderRef.contents(v);
+    }
+}
+function makeExtra(extra) {
+    if (extra != null) {
+        return (0, _Map.map)((_arg, tupledArg)=>new _Types.FSharpRef(tupledArg[0]), (0, _Option.value)(extra).Coders);
+    } else {
+        return (0, _Map.empty)({
+            Compare: _Util.comparePrimitives
+        });
+    }
+}
+class Auto {
+    constructor(){}
+}
+function Auto_$reflection() {
+    return (0, _Reflection.class_type)("Thoth.Json.Encode.Auto", undefined, Auto);
+}
+function Auto_generateBoxedEncoderCached_437914C6(t, caseStrategy, extra, skipNullField) {
+    let y_1, y;
+    const caseStrategy_1 = (0, _Option.defaultArg)(caseStrategy, (0, _Typesfs.CaseStrategy_PascalCase)());
+    const skipNullField_1 = (0, _Option.defaultArg)(skipNullField, true);
+    return (0, _Typesfs.Util_Cache$1__GetOrAdd_43981464)(_Typesfs.Util_CachedEncoders, (y_1 = (y = (0, _Reflection.fullName)(t), (0, _Types.toString)(caseStrategy_1) + y), (0, _Option.defaultArg)((0, _Option.map)((e)=>e.Hash, extra), "") + y_1), ()=>autoEncoder(makeExtra(extra), caseStrategy_1, skipNullField_1, t));
+}
+function Auto_generateBoxedEncoder_437914C6(t, caseStrategy, extra, skipNullField) {
+    const caseStrategy_1 = (0, _Option.defaultArg)(caseStrategy, (0, _Typesfs.CaseStrategy_PascalCase)());
+    const skipNullField_1 = (0, _Option.defaultArg)(skipNullField, true);
+    return autoEncoder(makeExtra(extra), caseStrategy_1, skipNullField_1, t);
+}
+function encode(space, value) {
+    return toString(space, value);
+} //# sourceMappingURL=Encode.fs.ts.map
+
+//# sourceMappingURL=Encode.fs.js.map

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Encode.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Encode.fs.ts"],"names":["value","o","enumerator","values","forLoopVar","object","enc1","v1","enc2","v2","enc3","v3","enc4","v4","enc5","v5","enc6","v6","enc7","v7","enc8","v8","list","tuple2","keyEncoder","valueEncoder","tupledArg","space","encoder","nil","arg10","encoderRef","extra","matchValue","t","setters","targetKey","caseStrategy","fi","encode","autoEncoder","skipNullField","source","target","set","patternInput","info","fields","len","fieldTypes","i","fullname","seq","enumType","clo2","encoders","x","option","keyType","activePatternResult9193","_arg1","clo4","activePatternResult9217","_arg2","autoEncodeRecordsAndUnions","unit","datetime","datetimeOffset","timespan","guid","v","y","e","makeExtra","toString"],"mappings":"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"}

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Encode.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Encode.fs"],"names":["value","o","enumerator","values","forLoopVar","object","enc1","v1","enc2","v2","enc3","v3","enc4","v4","enc5","v5","enc6","v6","enc7","v7","enc8","v8","list","tuple2","keyEncoder","valueEncoder","tupledArg","space","encoder","nil","arg10","encoderRef","extra","matchValue","t","setters","targetKey","caseStrategy","fi","encode","autoEncoder","skipNullField","source","target","set","patternInput","info","fields","len","fieldTypes","i","fullname","seq","enumType","clo2","encoders","x","option","keyType","activePatternResult9193","_arg1","clo4","activePatternResult9217","_arg2","autoEncodeRecordsAndUnions","unit","datetime","datetimeOffset","timespan","guid","v","y","e","makeExtra","toString"],"mappings":"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","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Extra.fs

@@ -0,0 +1,47 @@
+[<RequireQualifiedAccess>]
+module Thoth.Json.Extra
+
+open Fable.Core
+
+#if !FABLE_REPL_LIB
+let empty: ExtraCoders =
+    {
+        Hash = ""
+        Coders = Map.empty
+    }
+
+let inline internal withCustomAndKey
+    (encoder: Encoder<'Value>)
+    (decoder: Decoder<'Value>)
+    (extra: ExtraCoders)
+    : ExtraCoders
+    =
+    { extra with
+        Hash = System.Guid.NewGuid().ToString()
+        Coders =
+            extra.Coders
+            |> Map.add
+                typeof<'Value>.FullName
+                (Encode.boxEncoder encoder, Decode.boxDecoder decoder)
+    }
+
+let inline withCustom
+    (encoder: Encoder<'Value>)
+    (decoder: Decoder<'Value>)
+    (extra: ExtraCoders)
+    : ExtraCoders
+    =
+    withCustomAndKey encoder decoder extra
+
+let inline withInt64 (extra: ExtraCoders) : ExtraCoders =
+    withCustomAndKey Encode.int64 Decode.int64 extra
+
+let inline withUInt64 (extra: ExtraCoders) : ExtraCoders =
+    withCustomAndKey Encode.uint64 Decode.uint64 extra
+
+let inline withDecimal (extra: ExtraCoders) : ExtraCoders =
+    withCustomAndKey Encode.decimal Decode.decimal extra
+
+let inline withBigInt (extra: ExtraCoders) : ExtraCoders =
+    withCustomAndKey Encode.bigint Decode.bigint extra
+#endif

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Extra.fs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "empty", {
+    enumerable: true,
+    get: function() {
+        return empty;
+    }
+});
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _Typesfs = require("./Types.fs.js");
+const empty = new _Typesfs.ExtraCoders("", (0, _Map.empty)({
+    Compare: _Util.comparePrimitives
+})); //# sourceMappingURL=Extra.fs.ts.map
+
+//# sourceMappingURL=Extra.fs.js.map

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Extra.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Extra.fs.ts"],"names":[],"mappings":";;;;;;;;;;;;;cAOI,IAAA,oBAAA,CACW,QACE,UAAA,EAAA"}

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Extra.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Extra.fs"],"names":[],"mappings":";;;;;;kCAOI,gBACW,IACE","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Thoth.Json.fableproj

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <Description>
+            Elm-inspired encoder and decoder for JSON, this package is intended to be use on Fable
+            side only.
+
+            If you are interested on using it against .NET Core or .NET Framework, please use
+            Thoth.Json.Net.
+        </Description>
+        <FablePackageType>library</FablePackageType>
+        <PackageTags>fable-javascript;fsharp;json</PackageTags>
+    </PropertyGroup>
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Types.fs" />
+        <Compile Include="Decode.fs" />
+        <Compile Include="Encode.fs" />
+        <Compile Include="Extra.fs" />
+    </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="EasyBuild.PackageReleaseNotes.Tasks">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Fable.Core" />
+        <PackageReference Include="Fable.Package.SDK">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+</Project>

package/FormSpec.TS/fable_modules/Thoth.Json.10.4.1/Types.fs

@@ -0,0 +1,68 @@
+namespace Thoth.Json
+
+open System.Text.RegularExpressions
+
+type JsonValue = obj
+
+type ErrorReason =
+    | BadPrimitive of string * JsonValue
+    | BadPrimitiveExtra of string * JsonValue * string
+    | BadType of string * JsonValue
+    | BadField of string * JsonValue
+    | BadPath of string * JsonValue * string
+    | TooSmallArray of string * JsonValue
+    | FailMessage of string
+    | BadOneOf of string list
+
+type CaseStrategy =
+    | PascalCase
+    | CamelCase
+    | SnakeCase
+
+type DecoderError = string * ErrorReason
+
+type Decoder<'T> = string -> JsonValue -> Result<'T, DecoderError>
+
+type Encoder<'T> = 'T -> JsonValue
+
+type BoxedDecoder = Decoder<obj>
+
+type BoxedEncoder = Encoder<obj>
+
+type ExtraCoders =
+    {
+        Hash: string
+        Coders: Map<string, BoxedEncoder * BoxedDecoder>
+    }
+
+module internal Util =
+    open System.Collections.Generic
+
+    type Cache<'Value>() =
+        let cache = Dictionary<string, 'Value>()
+
+        member __.GetOrAdd(key, factory) =
+            match cache.TryGetValue(key) with
+            | true, x -> x
+            | false, _ ->
+                let x = factory ()
+                cache.Add(key, x)
+                x
+
+    // Tree shaking will remove this if not used
+    // so no need to make them lazy in Fable
+    let CachedEncoders = Cache<BoxedEncoder>()
+    let CachedDecoders = Cache<BoxedDecoder>()
+
+    module Casing =
+        let lowerFirst (str: string) =
+            str.[..0].ToLowerInvariant() + str.[1..]
+
+        let convert caseStrategy fieldName =
+            match caseStrategy with
+            | CamelCase -> lowerFirst fieldName
+            | SnakeCase ->
+                Regex
+                    .Replace(lowerFirst fieldName, "[A-Z]", "_$0")
+                    .ToLowerInvariant()
+            | PascalCase -> fieldName