@nfdi4plants/arctrl 1.0.7 → 1.2.0

package/fable_modules/Thoth.Json.Core.0.2.1/Encode.fs

@@ -0,0 +1,233 @@
+namespace Thoth.Json.Core
+
+open Fable.Core
+open System.Globalization
+open System
+
+[<RequireQualifiedAccess>]
+module Encode =
+
+    let inline string value = Json.String value
+    let inline char value = Json.Char value
+    let inline guid value = value.ToString() |> string
+    let inline float value = Json.DecimalNumber value
+
+    let float32 (value: float32) =
+        Json.DecimalNumber(Operators.float value)
+
+    let inline decimal (value: decimal) =
+        value.ToString(CultureInfo.InvariantCulture) |> string
+
+    let inline nil<'T> = Json.Null
+    let inline bool value = Json.Boolean value
+    let inline object values = Json.Object values
+    let inline array values = Json.Array values
+    let list values = Json.Array(values |> List.toArray)
+    let seq values = Json.Array(values |> Seq.toArray)
+    let dict (values: Map<string, Json>) : Json = values |> Map.toList |> object
+
+    let inline bigint (value: bigint) = value.ToString() |> string
+
+    let inline datetimeOffset (value: DateTimeOffset) =
+        value.ToString("O", CultureInfo.InvariantCulture) |> string
+
+    let inline timespan value = value.ToString() |> string
+
+    let inline datetime (value: DateTime) =
+        value.ToString("O", CultureInfo.InvariantCulture) |> string
+
+    let inline sbyte (value: sbyte) = Json.IntegralNumber(uint32 value)
+    let inline byte (value: byte) = Json.IntegralNumber(uint32 value)
+    let inline int16 (value: int16) = Json.IntegralNumber(uint32 value)
+    let inline uint16 (value: uint16) = Json.IntegralNumber(uint32 value)
+    let inline int (value: int) = Json.IntegralNumber(uint32 value)
+    let inline uint32 (value: uint32) = Json.IntegralNumber value
+
+    let inline int64 (value: int64) =
+        value.ToString(CultureInfo.InvariantCulture) |> string
+
+    let inline uint64 (value: uint64) =
+        value.ToString(CultureInfo.InvariantCulture) |> string
+
+    let inline unit () = Json.Unit
+
+    let tuple2 (enc1: Encoder<'T1>) (enc2: Encoder<'T2>) (v1, v2) : Json =
+        array
+            [|
+                enc1 v1
+                enc2 v2
+            |]
+
+    let tuple3
+        (enc1: Encoder<'T1>)
+        (enc2: Encoder<'T2>)
+        (enc3: Encoder<'T3>)
+        (v1, v2, v3)
+        : Json
+        =
+        array
+            [|
+                enc1 v1
+                enc2 v2
+                enc3 v3
+            |]
+
+    let tuple4
+        (enc1: Encoder<'T1>)
+        (enc2: Encoder<'T2>)
+        (enc3: Encoder<'T3>)
+        (enc4: Encoder<'T4>)
+        (v1, v2, v3, v4)
+        : Json
+        =
+        array
+            [|
+                enc1 v1
+                enc2 v2
+                enc3 v3
+                enc4 v4
+            |]
+
+    let tuple5
+        (enc1: Encoder<'T1>)
+        (enc2: Encoder<'T2>)
+        (enc3: Encoder<'T3>)
+        (enc4: Encoder<'T4>)
+        (enc5: Encoder<'T5>)
+        (v1, v2, v3, v4, v5)
+        : Json
+        =
+        array
+            [|
+                enc1 v1
+                enc2 v2
+                enc3 v3
+                enc4 v4
+                enc5 v5
+            |]
+
+    let tuple6
+        (enc1: Encoder<'T1>)
+        (enc2: Encoder<'T2>)
+        (enc3: Encoder<'T3>)
+        (enc4: Encoder<'T4>)
+        (enc5: Encoder<'T5>)
+        (enc6: Encoder<'T6>)
+        (v1, v2, v3, v4, v5, v6)
+        : Json
+        =
+        array
+            [|
+                enc1 v1
+                enc2 v2
+                enc3 v3
+                enc4 v4
+                enc5 v5
+                enc6 v6
+            |]
+
+    let tuple7
+        (enc1: Encoder<'T1>)
+        (enc2: Encoder<'T2>)
+        (enc3: Encoder<'T3>)
+        (enc4: Encoder<'T4>)
+        (enc5: Encoder<'T5>)
+        (enc6: Encoder<'T6>)
+        (enc7: Encoder<'T7>)
+        (v1, v2, v3, v4, v5, v6, v7)
+        : Json
+        =
+        array
+            [|
+                enc1 v1
+                enc2 v2
+                enc3 v3
+                enc4 v4
+                enc5 v5
+                enc6 v6
+                enc7 v7
+            |]
+
+    let tuple8
+        (enc1: Encoder<'T1>)
+        (enc2: Encoder<'T2>)
+        (enc3: Encoder<'T3>)
+        (enc4: Encoder<'T4>)
+        (enc5: Encoder<'T5>)
+        (enc6: Encoder<'T6>)
+        (enc7: Encoder<'T7>)
+        (enc8: Encoder<'T8>)
+        (v1, v2, v3, v4, v5, v6, v7, v8)
+        : Json
+        =
+        array
+            [|
+                enc1 v1
+                enc2 v2
+                enc3 v3
+                enc4 v4
+                enc5 v5
+                enc6 v6
+                enc7 v7
+                enc8 v8
+            |]
+
+
+    let map
+        (keyEncoder: Encoder<'key>)
+        (valueEncoder: Encoder<'value>)
+        (values: Map<'key, 'value>)
+        : Json
+        =
+        values
+        |> Map.toList
+        |> List.map (tuple2 keyEncoder valueEncoder)
+        |> list
+
+    ////////////
+    /// Enum ///
+    ///////////
+
+    module Enum =
+
+        let byte<'TEnum when 'TEnum: enum<byte>> (value: 'TEnum) : Json =
+            LanguagePrimitives.EnumToValue value |> byte
+
+        let sbyte<'TEnum when 'TEnum: enum<sbyte>> (value: 'TEnum) : Json =
+            LanguagePrimitives.EnumToValue value |> sbyte
+
+        let int16<'TEnum when 'TEnum: enum<int16>> (value: 'TEnum) : Json =
+            LanguagePrimitives.EnumToValue value |> int16
+
+        let uint16<'TEnum when 'TEnum: enum<uint16>> (value: 'TEnum) : Json =
+            LanguagePrimitives.EnumToValue value |> uint16
+
+        let int<'TEnum when 'TEnum: enum<int>> (value: 'TEnum) : Json =
+            LanguagePrimitives.EnumToValue value |> int
+
+        let uint32<'TEnum when 'TEnum: enum<uint32>> (value: 'TEnum) : Json =
+            LanguagePrimitives.EnumToValue value |> uint32
+
+    let option (encoder: 'a -> Json) =
+        Option.map encoder >> Option.defaultWith (fun _ -> nil)
+
+    let rec toJsonValue (helpers: IEncoderHelpers<'JsonValue>) (json: Json) =
+        match json with
+        | Json.String value -> helpers.encodeString value
+        | Json.IntegralNumber value -> helpers.encodeIntegralNumber value
+        | Json.Object values ->
+            let o = helpers.createEmptyObject ()
+
+            values
+            |> Seq.iter (fun (k, v) ->
+                helpers.setPropertyOnObject (o, k, toJsonValue helpers v)
+            )
+
+            o
+        | Json.Char value -> helpers.encodeChar value
+        | Json.DecimalNumber value -> helpers.encodeDecimalNumber value
+        | Json.Null -> helpers.encodeNull ()
+        | Json.Boolean value -> helpers.encodeBool value
+        | Json.Array value ->
+            value |> Array.map (toJsonValue helpers) |> helpers.encodeArray
+        | Json.Unit -> helpers.encodeNull ()

package/fable_modules/Thoth.Json.Core.0.2.1/Encode.fs.js

@@ -0,0 +1,113 @@
+import { Json } from "./Types.fs.js";
+import { map as map_1, toArray } from "../fable-library-js.4.13.0/List.js";
+import { iterate, toArray as toArray_1 } from "../fable-library-js.4.13.0/Seq.js";
+import { toList } from "../fable-library-js.4.13.0/Map.js";
+import { map as map_2, defaultArgWith } from "../fable-library-js.4.13.0/Option.js";
+import { map as map_3 } from "../fable-library-js.4.13.0/Array.js";
+
+export function float32(value) {
+    return new Json(2, [value]);
+}
+
+export function list(values) {
+    return new Json(6, [toArray(values)]);
+}
+
+export function seq(values) {
+    return new Json(6, [toArray_1(values)]);
+}
+
+export function dict(values) {
+    return new Json(5, [toList(values)]);
+}
+
+export function tuple2(enc1, enc2, v1, v2) {
+    return new Json(6, [[enc1(v1), enc2(v2)]]);
+}
+
+export function tuple3(enc1, enc2, enc3, v1, v2, v3) {
+    return new Json(6, [[enc1(v1), enc2(v2), enc3(v3)]]);
+}
+
+export function tuple4(enc1, enc2, enc3, enc4, v1, v2, v3, v4) {
+    return new Json(6, [[enc1(v1), enc2(v2), enc3(v3), enc4(v4)]]);
+}
+
+export function tuple5(enc1, enc2, enc3, enc4, enc5, v1, v2, v3, v4, v5) {
+    return new Json(6, [[enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5)]]);
+}
+
+export function tuple6(enc1, enc2, enc3, enc4, enc5, enc6, v1, v2, v3, v4, v5, v6) {
+    return new Json(6, [[enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6)]]);
+}
+
+export function tuple7(enc1, enc2, enc3, enc4, enc5, enc6, enc7, v1, v2, v3, v4, v5, v6, v7) {
+    return new Json(6, [[enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7)]]);
+}
+
+export function tuple8(enc1, enc2, enc3, enc4, enc5, enc6, enc7, enc8, v1, v2, v3, v4, v5, v6, v7, v8) {
+    return new Json(6, [[enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7), enc8(v8)]]);
+}
+
+export function map(keyEncoder, valueEncoder, values) {
+    return list(map_1((tupledArg) => tuple2(keyEncoder, valueEncoder, tupledArg[0], tupledArg[1]), toList(values)));
+}
+
+export function Enum_byte(value) {
+    return new Json(7, [value]);
+}
+
+export function Enum_sbyte(value) {
+    return new Json(7, [value >>> 0]);
+}
+
+export function Enum_int16(value) {
+    return new Json(7, [value >>> 0]);
+}
+
+export function Enum_uint16(value) {
+    return new Json(7, [value]);
+}
+
+export function Enum_int(value) {
+    return new Json(7, [value >>> 0]);
+}
+
+export function Enum_uint32(value) {
+    return new Json(7, [value]);
+}
+
+export function option(encoder) {
+    return (arg) => defaultArgWith(map_2(encoder, arg), () => (new Json(3, [])));
+}
+
+export function toJsonValue(helpers, json) {
+    switch (json.tag) {
+        case 7:
+            return helpers.encodeIntegralNumber(json.fields[0]);
+        case 5: {
+            const o = helpers.createEmptyObject();
+            iterate((tupledArg) => {
+                helpers.setPropertyOnObject(o, tupledArg[0], toJsonValue(helpers, tupledArg[1]));
+            }, json.fields[0]);
+            return o;
+        }
+        case 1:
+            return helpers.encodeChar(json.fields[0]);
+        case 2:
+            return helpers.encodeDecimalNumber(json.fields[0]);
+        case 3:
+            return helpers.encodeNull();
+        case 4:
+            return helpers.encodeBool(json.fields[0]);
+        case 6: {
+            const arg = map_3((json_1) => toJsonValue(helpers, json_1), json.fields[0]);
+            return helpers.encodeArray(arg);
+        }
+        case 8:
+            return helpers.encodeNull();
+        default:
+            return helpers.encodeString(json.fields[0]);
+    }
+}
+

package/fable_modules/Thoth.Json.Core.0.2.1/Thoth.Json.Core.fableproj

@@ -0,0 +1,28 @@
+<?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>
+        <PackageTags>fable;fsharp;json</PackageTags>
+    </PropertyGroup>
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Types.fs" />
+        <Compile Include="Decode.fs" />
+        <Compile Include="Encode.fs" />
+        <!-- <Compile Include="Extra.fs" /> -->
+    </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="Fable.Core" />
+        <PackageReference Include="Ionide.KeepAChangelog.Tasks" PrivateAssets="all" />
+    </ItemGroup>
+    <ItemGroup>
+        <Content Include="*.fsproj; **\*.fs" PackagePath="fable" />
+    </ItemGroup>
+</Project>

package/fable_modules/Thoth.Json.Core.0.2.1/Types.fs

@@ -0,0 +1,76 @@
+namespace Thoth.Json.Core
+
+type IDecoderHelpers<'JsonValue> =
+    abstract isString: 'JsonValue -> bool
+    abstract isNumber: 'JsonValue -> bool
+    abstract isBoolean: 'JsonValue -> bool
+    abstract isNullValue: 'JsonValue -> bool
+    abstract isArray: 'JsonValue -> bool
+    abstract isObject: 'JsonValue -> bool
+    abstract hasProperty: string -> 'JsonValue -> bool
+    abstract isIntegralValue: 'JsonValue -> bool
+    abstract asString: 'JsonValue -> string
+    abstract asFloat: 'JsonValue -> float
+    abstract asFloat32: 'JsonValue -> float32
+    abstract asInt: 'JsonValue -> int
+    abstract asBoolean: 'JsonValue -> bool
+    abstract asArray: 'JsonValue -> 'JsonValue[]
+    abstract getProperty: string * 'JsonValue -> 'JsonValue
+    abstract getProperties: 'JsonValue -> string seq
+    abstract anyToString: 'JsonValue -> string
+
+type IEncoderHelpers<'JsonValue> =
+    abstract encodeString: string -> 'JsonValue
+    abstract encodeChar: char -> 'JsonValue
+    abstract encodeDecimalNumber: float -> 'JsonValue
+    abstract encodeBool: bool -> 'JsonValue
+    abstract encodeNull: unit -> 'JsonValue
+    abstract createEmptyObject: unit -> 'JsonValue
+    abstract setPropertyOnObject: 'JsonValue * string * 'JsonValue -> unit
+    abstract encodeArray: 'JsonValue array -> 'JsonValue
+    abstract encodeList: 'JsonValue list -> 'JsonValue
+    abstract encodeSeq: 'JsonValue seq -> 'JsonValue
+    abstract encodeIntegralNumber: uint32 -> 'JsonValue
+
+
+type ErrorReason<'JsonValue> =
+    | 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 DecoderError<'JsonValue> list
+
+and DecoderError<'JsonValue> = string * ErrorReason<'JsonValue>
+
+type Decoder<'T> =
+    abstract member Decode<'JsonValue> :
+        helpers: IDecoderHelpers<'JsonValue> * value: 'JsonValue ->
+            Result<'T, DecoderError<'JsonValue>>
+
+/// <summary>
+/// A JSON value
+/// </summary>
+/// <remarks>
+/// Some types don't have a direct representation in this DU,
+/// this to make sure we represent them in the same way between the different
+/// backends.
+///
+/// For example, <c>decimal</c> use <c>string</c> as the underlying type.
+/// </remarks>
+[<RequireQualifiedAccess; NoComparison>]
+type Json =
+    | String of string
+    | Char of char
+    | DecimalNumber of float
+    | Null
+    | Boolean of bool
+    | Object of (string * Json) seq
+    | Array of Json[]
+    // Thoth.Json as an abritrary limit to the size of numbers
+    | IntegralNumber of uint32
+    | Unit
+
+type Encoder<'T> = 'T -> Json

package/fable_modules/Thoth.Json.Core.0.2.1/Types.fs.js

@@ -0,0 +1,33 @@
+import { Union } from "../fable-library-js.4.13.0/Types.js";
+import { uint32_type, array_type, class_type, bool_type, float64_type, char_type, union_type, list_type, tuple_type, string_type } from "../fable-library-js.4.13.0/Reflection.js";
+
+export class ErrorReason$1 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["BadPrimitive", "BadPrimitiveExtra", "BadType", "BadField", "BadPath", "TooSmallArray", "FailMessage", "BadOneOf"];
+    }
+}
+
+export function ErrorReason$1_$reflection(gen0) {
+    return union_type("Thoth.Json.Core.ErrorReason`1", [gen0], ErrorReason$1, () => [[["Item1", string_type], ["Item2", gen0]], [["Item1", string_type], ["Item2", gen0], ["Item3", string_type]], [["Item1", string_type], ["Item2", gen0]], [["Item1", string_type], ["Item2", gen0]], [["Item1", string_type], ["Item2", gen0], ["Item3", string_type]], [["Item1", string_type], ["Item2", gen0]], [["Item", string_type]], [["Item", list_type(tuple_type(string_type, ErrorReason$1_$reflection(gen0)))]]]);
+}
+
+export class Json extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["String", "Char", "DecimalNumber", "Null", "Boolean", "Object", "Array", "IntegralNumber", "Unit"];
+    }
+}
+
+export function Json_$reflection() {
+    return union_type("Thoth.Json.Core.Json", [], Json, () => [[["Item", string_type]], [["Item", char_type]], [["Item", float64_type]], [], [["Item", bool_type]], [["Item", class_type("System.Collections.Generic.IEnumerable`1", [tuple_type(string_type, Json_$reflection())])]], [["Item", array_type(Json_$reflection())]], [["Item", uint32_type]], []]);
+}
+

package/fable_modules/Thoth.Json.Core.0.2.1/obj/Debug/netstandard2.0/.NETStandard,Version=v2.0.AssemblyAttributes.fs

@@ -0,0 +1,3 @@
+namespace Microsoft.BuildSettings
+                [<System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName=".NET Standard 2.0")>]
+                do ()

package/fable_modules/{Thoth.Json.10.1.0/obj/Release/netstandard2.0/Thoth.Json.AssemblyInfo.fs → Thoth.Json.Core.0.2.1/obj/Debug/netstandard2.0/Thoth.Json.Core.AssemblyInfo.fs}

@@ -7,13 +7,14 @@ open System
 open System.Reflection
 
 
+[<assembly: System.Reflection.AssemblyMetadataAttribute("BuildDate", "2023-12-12")>]
 [<assembly: System.Reflection.AssemblyCompanyAttribute("Maxime Mangel")>]
-[<assembly: System.Reflection.AssemblyConfigurationAttribute("Release")>]
-[<assembly: System.Reflection.AssemblyDescriptionAttribute("\nElm-inspired encoder and decoder for JSON, this package is intended to be use on Fable side only.\n\nIf you are interested on using it against .NET Core or .NET Framework, please use Thoth.Json.Net.\n    ")>]
-[<assembly: System.Reflection.AssemblyFileVersionAttribute("10.1.0.0")>]
-[<assembly: System.Reflection.AssemblyInformationalVersionAttribute("10.1.0")>]
-[<assembly: System.Reflection.AssemblyProductAttribute("Thoth.Json")>]
-[<assembly: System.Reflection.AssemblyTitleAttribute("Thoth.Json")>]
-[<assembly: System.Reflection.AssemblyVersionAttribute("10.1.0.0")>]
+[<assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")>]
+[<assembly: System.Reflection.AssemblyDescriptionAttribute("\nElm-inspired encoder and decoder for JSON, this package is intended to be use on Fable side only.\n\nIf you are interested on using it against .NET Core or .NET Framework, please use Thoth.Json.Net.\n        ")>]
+[<assembly: System.Reflection.AssemblyFileVersionAttribute("0.2.1.0")>]
+[<assembly: System.Reflection.AssemblyInformationalVersionAttribute("0.2.1")>]
+[<assembly: System.Reflection.AssemblyProductAttribute("Thoth.Json.Core")>]
+[<assembly: System.Reflection.AssemblyTitleAttribute("Thoth.Json.Core")>]
+[<assembly: System.Reflection.AssemblyVersionAttribute("0.2.1.0")>]
 [<assembly: System.Reflection.AssemblyMetadataAttribute("RepositoryUrl", "https://github.com/thoth-org/Thoth.Json")>]
 do()

package/fable_modules/Thoth.Json.JavaScript.0.1.0/Decode.fs

@@ -0,0 +1,79 @@
+namespace Thoth.Json.JavaScript
+
+open Fable.Core
+open Fable.Core.JsInterop
+open Thoth.Json.Core
+
+[<RequireQualifiedAccess>]
+module Decode =
+
+    let helpers =
+        { new IDecoderHelpers<obj> with
+            member _.isString jsonValue = jsonValue :? string
+            member _.isNumber jsonValue = jsTypeof jsonValue = "number"
+            member _.isBoolean jsonValue = jsonValue :? bool
+            member _.isNullValue jsonValue = isNull jsonValue
+
+            member _.isArray jsonValue =
+                JS.Constructors.Array.isArray (jsonValue)
+
+            member _.isObject jsonValue =
+                emitJsStatement
+                    jsonValue
+                    """
+return $0 === null ? false : (Object.getPrototypeOf($0 || false) === Object.prototype)
+                """
+
+            member _.hasProperty fieldName jsonValue =
+                emitJsStatement
+                    (jsonValue, fieldName)
+                    """
+return $0.hasOwnProperty($1);
+                    """
+
+            member _.isIntegralValue jsonValue =
+                emitJsStatement
+                    jsonValue
+                    """
+return isFinite($0) && Math.floor($0) === $0
+                    """
+
+            member _.asString jsonValue = unbox jsonValue
+            member _.asBoolean jsonValue = unbox jsonValue
+            member _.asArray jsonValue = unbox jsonValue
+            member _.asFloat jsonValue = unbox jsonValue
+            member _.asFloat32 jsonValue = unbox jsonValue
+            member _.asInt jsonValue = unbox jsonValue
+
+            member _.getProperties jsonValue =
+                upcast JS.Constructors.Object.keys (jsonValue)
+
+            member _.getProperty(fieldName: string, jsonValue: obj) =
+                jsonValue?(fieldName)
+
+            member _.anyToString jsonValue =
+                emitJsStatement
+                    jsonValue
+                    """
+return JSON.stringify($0, null, 4) + ''
+                    """
+        }
+
+    module Helpers =
+
+        [<Emit("$0 instanceof SyntaxError")>]
+        let isSyntaxError (_: obj) : bool = jsNative
+
+    let fromString (decoder: Decoder<'T>) =
+        fun value ->
+            try
+                let json = JS.JSON.parse value
+
+                match decoder.Decode(helpers, json) with
+                | Ok success -> Ok success
+                | Error error ->
+                    let finalError = error |> Decode.Helpers.prependPath "$"
+                    Error(Decode.errorToString helpers finalError)
+
+            with ex when Helpers.isSyntaxError ex ->
+                Error("Given an invalid JSON: " + ex.Message)

package/fable_modules/Thoth.Json.JavaScript.0.1.0/Decode.fs.js

@@ -0,0 +1,85 @@
+import { FSharpResult$2 } from "../fable-library-js.4.13.0/Result.js";
+import { errorToString, Helpers_prependPath } from "../Thoth.Json.Core.0.2.1/Decode.fs.js";
+
+export const helpers = {
+    isString(jsonValue) {
+        return typeof jsonValue === "string";
+    },
+    isNumber(jsonValue_1) {
+        return (typeof jsonValue_1) === "number";
+    },
+    isBoolean(jsonValue_2) {
+        return typeof jsonValue_2 === "boolean";
+    },
+    isNullValue(jsonValue_3) {
+        return jsonValue_3 == null;
+    },
+    isArray(jsonValue_4) {
+        return Array.isArray(jsonValue_4);
+    },
+    isObject(jsonValue_5) {
+        return jsonValue_5 === null ? false : (Object.getPrototypeOf(jsonValue_5 || false) === Object.prototype)
+                ;
+    },
+    hasProperty(fieldName, jsonValue_6) {
+        return jsonValue_6.hasOwnProperty(fieldName);
+                    ;
+    },
+    isIntegralValue(jsonValue_7) {
+        return isFinite(jsonValue_7) && Math.floor(jsonValue_7) === jsonValue_7
+                    ;
+    },
+    asString(jsonValue_8) {
+        return jsonValue_8;
+    },
+    asBoolean(jsonValue_9) {
+        return jsonValue_9;
+    },
+    asArray(jsonValue_10) {
+        return jsonValue_10;
+    },
+    asFloat(jsonValue_11) {
+        return jsonValue_11;
+    },
+    asFloat32(jsonValue_12) {
+        return jsonValue_12;
+    },
+    asInt(jsonValue_13) {
+        return jsonValue_13;
+    },
+    getProperties(jsonValue_14) {
+        return Object.keys(jsonValue_14);
+    },
+    getProperty(fieldName_1, jsonValue_15) {
+        return jsonValue_15[fieldName_1];
+    },
+    anyToString(jsonValue_16) {
+        return JSON.stringify(jsonValue_16, null, 4) + ''
+                    ;
+    },
+};
+
+export function fromString(decoder, value) {
+    try {
+        const json = JSON.parse(value);
+        const matchValue = decoder.Decode(helpers, json);
+        if (matchValue.tag === 1) {
+            let finalError;
+            const tupledArg = matchValue.fields[0];
+            finalError = Helpers_prependPath("$", tupledArg[0], tupledArg[1]);
+            return new FSharpResult$2(1, [errorToString(helpers, finalError[0], finalError[1])]);
+        }
+        else {
+            return new FSharpResult$2(0, [matchValue.fields[0]]);
+        }
+    }
+    catch (matchValue_1) {
+        if (matchValue_1 instanceof SyntaxError) {
+            return new FSharpResult$2(1, ["Given an invalid JSON: " + matchValue_1.message]);
+        }
+        else {
+            throw matchValue_1;
+        }
+    }
+}
+