@magnusopera/fscript 0.75.0

package/dist/Library.js

@@ -0,0 +1,732 @@
+
+import { Record } from "./fable_modules/fable-library-js.5.2.0/Types.js";
+import { obj_type, class_type, record_type, list_type, string_type } from "./fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { Stmt_$reflection } from "./FScript.Language/Ast.js";
+import { ExternalFunction, MapKey, Value, Value_$reflection, ExternalFunction_$reflection } from "./FScript.Language/Value.js";
+import { inferProgramWithExterns, TypedStmt_$reflection } from "./FScript.Language/TypeInfer.js";
+import { Scheme, Type, Types_typeToString, Type_$reflection } from "./FScript.Language/Types.js";
+import { map, defaultArg, value as value_18, some } from "./fable_modules/fable-library-js.5.2.0/Option.js";
+import { stringHash, compare, comparePrimitives, createObj, Exception } from "./fable_modules/fable-library-js.5.2.0/Util.js";
+import { concat } from "./fable_modules/fable-library-js.5.2.0/String.js";
+import { EvalError$, EvalException, TypeException, ParseException } from "./FScript.Language/Error.js";
+import { toInt32_unchecked, fromFloat64, toInt64_unchecked } from "./fable_modules/fable-library-js.5.2.0/BigInt.js";
+import { parse as parse_1 } from "./fable_modules/fable-library-js.5.2.0/Long.js";
+import { parse as parse_2 } from "./fable_modules/fable-library-js.5.2.0/Int32.js";
+import { append, choose, sort, filter, exists, singleton, collect, empty, ofArray, length, map as map_1, toArray } from "./fable_modules/fable-library-js.5.2.0/List.js";
+import { FSharpMap__get_Item, FSharpMap__TryFind, ofList, toList } from "./fable_modules/fable-library-js.5.2.0/Map.js";
+import { parseProgramFromSourceWithIncludesResolver } from "./FScript.Language/IncludeResolver.js";
+import { invokeValue, evalProgramWithExterns, evalProgramWithExternsState } from "./FScript.Language/Eval.js";
+import { List_distinct } from "./fable_modules/fable-library-js.5.2.0/Seq2.js";
+import { FSharpSet__Contains, ofList as ofList_1 } from "./fable_modules/fable-library-js.5.2.0/Set.js";
+import { valueToString } from "./FScript.Language/Pretty.js";
+import { Span, Position } from "./FScript.Language/Span.js";
+
+export class ParsedProgramHandle extends Record {
+    constructor(kind, program, externs) {
+        super();
+        this.kind = kind;
+        this.program = program;
+        this.externs = externs;
+    }
+}
+
+export function ParsedProgramHandle_$reflection() {
+    return record_type("FScript.JavaScript.ParsedProgramHandle", [], ParsedProgramHandle, () => [["kind", string_type], ["program", list_type(Stmt_$reflection())], ["externs", list_type(ExternalFunction_$reflection())]]);
+}
+
+export class TypedProgramHandle extends Record {
+    constructor(kind, typedProgram, externs) {
+        super();
+        this.kind = kind;
+        this.typedProgram = typedProgram;
+        this.externs = externs;
+    }
+}
+
+export function TypedProgramHandle_$reflection() {
+    return record_type("FScript.JavaScript.TypedProgramHandle", [], TypedProgramHandle, () => [["kind", string_type], ["typedProgram", list_type(TypedStmt_$reflection())], ["externs", list_type(ExternalFunction_$reflection())]]);
+}
+
+export class LoadedScriptHandle extends Record {
+    constructor(kind, typeDefs, env, exportedFunctionNames, exportedFunctionSet, exportedFunctions, exportedValueNames, exportedValueSet, exportedValues, lastValue, externs) {
+        super();
+        this.kind = kind;
+        this.typeDefs = typeDefs;
+        this.env = env;
+        this.exportedFunctionNames = exportedFunctionNames;
+        this.exportedFunctionSet = exportedFunctionSet;
+        this.exportedFunctions = exportedFunctions;
+        this.exportedValueNames = exportedValueNames;
+        this.exportedValueSet = exportedValueSet;
+        this.exportedValues = exportedValues;
+        this.lastValue = lastValue;
+        this.externs = externs;
+    }
+}
+
+export function LoadedScriptHandle_$reflection() {
+    return record_type("FScript.JavaScript.LoadedScriptHandle", [], LoadedScriptHandle, () => [["kind", string_type], ["typeDefs", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Type_$reflection()])], ["env", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Value_$reflection()])], ["exportedFunctionNames", list_type(string_type)], ["exportedFunctionSet", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [string_type])], ["exportedFunctions", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Value_$reflection()])], ["exportedValueNames", list_type(string_type)], ["exportedValueSet", class_type("Microsoft.FSharp.Collections.FSharpSet`1", [string_type])], ["exportedValues", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Value_$reflection()])], ["lastValue", Value_$reflection()], ["externs", list_type(ExternalFunction_$reflection())]]);
+}
+
+export class SessionHandle extends Record {
+    constructor(kind, retainedProgram, options, externs) {
+        super();
+        this.kind = kind;
+        this.retainedProgram = retainedProgram;
+        this.options = options;
+        this.externs = externs;
+    }
+}
+
+export function SessionHandle_$reflection() {
+    return record_type("FScript.JavaScript.SessionHandle", [], SessionHandle, () => [["kind", string_type], ["retainedProgram", list_type(Stmt_$reflection())], ["options", obj_type], ["externs", list_type(ExternalFunction_$reflection())]]);
+}
+
+function tryGetProperty(name, value) {
+    if (typeof value === 'undefined' || value === null) {
+        return undefined;
+    }
+    else {
+        const property = value[name];
+        if (typeof property === 'undefined' || property === null) {
+            return undefined;
+        }
+        else {
+            return some(property);
+        }
+    }
+}
+
+function getRequiredProperty(name, value) {
+    const matchValue = tryGetProperty(name, value);
+    if (matchValue == null) {
+        throw new Exception(concat("Missing required property \'", name, "\'"));
+    }
+    else {
+        return value_18(matchValue);
+    }
+}
+
+function isFScriptError(value) {
+    const matchValue = tryGetProperty("kind", value);
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        return value_18(matchValue) === "fscript-error";
+    }
+}
+
+function positionToObj(position) {
+    return {
+        file: defaultArg(map((value) => value, position.File), null),
+        line: position.Line,
+        column: position.Column,
+    };
+}
+
+function spanToObj(span) {
+    return {
+        start: positionToObj(span.Start),
+        end: positionToObj(span.End),
+    };
+}
+
+function throwLanguageError(phase, message, span) {
+    return (() => { const e = new Error({
+        kind: "fscript-error",
+        phase: phase,
+        message: message,
+        span: spanToObj(span),
+    }.message); Object.assign(e, {
+        kind: "fscript-error",
+        phase: phase,
+        message: message,
+        span: spanToObj(span),
+    }); throw e; })();
+}
+
+function withStructuredErrors(work) {
+    try {
+        return work();
+    }
+    catch (matchValue) {
+        if (matchValue instanceof ParseException) {
+            const error = matchValue.Data0;
+            return throwLanguageError("parse", error.Message, error.Span);
+        }
+        else if (matchValue instanceof TypeException) {
+            const error_1 = matchValue.Data0;
+            return throwLanguageError("type", error_1.Message, error_1.Span);
+        }
+        else if (matchValue instanceof EvalException) {
+            const error_2 = matchValue.Data0;
+            return throwLanguageError("eval", error_2.Message, error_2.Span);
+        }
+        else {
+            const ex = matchValue;
+            const error_3 = ex;
+            return isFScriptError(error_3) ? ((() => { throw error_3; })()) : ((() => { const e = new Error({
+                kind: "fscript-error",
+                phase: "host",
+                message: ex.message,
+            }.message); Object.assign(e, {
+                kind: "fscript-error",
+                phase: "host",
+                message: ex.message,
+            }); throw e; })());
+        }
+    }
+}
+
+function int64FromObj(value) {
+    const matchValue = typeof value;
+    switch (matchValue) {
+        case "bigint":
+            return value;
+        case "number": {
+            if (!(Number.isSafeInteger(value))) {
+                throw new Exception("Expected a safe integer");
+            }
+            return toInt64_unchecked(fromFloat64(value));
+        }
+        case "string":
+            return toInt64_unchecked(parse_1(value, 511, false, 64));
+        default:
+            throw new Exception("Expected int value");
+    }
+}
+
+function intFromObj(value) {
+    const matchValue = typeof value;
+    switch (matchValue) {
+        case "number":
+            return ~~value | 0;
+        case "bigint":
+            return ~~toInt32_unchecked(value) | 0;
+        case "string":
+            return parse_2(value, 511, false, 32) | 0;
+        default:
+            throw new Exception("Expected numeric value");
+    }
+}
+
+function mapKeyToTagged(key) {
+    if (key.tag === 1) {
+        return {
+            kind: "int",
+            value: key.fields[0],
+        };
+    }
+    else {
+        return {
+            kind: "string",
+            value: key.fields[0],
+        };
+    }
+}
+
+function valueToTagged(value) {
+    switch (value.tag) {
+        case 1:
+            return {
+                kind: "int",
+                value: value.fields[0],
+            };
+        case 2:
+            return {
+                kind: "float",
+                value: value.fields[0],
+            };
+        case 3:
+            return {
+                kind: "bool",
+                value: value.fields[0],
+            };
+        case 4:
+            return {
+                kind: "string",
+                value: value.fields[0],
+            };
+        case 5:
+            return {
+                kind: "list",
+                values: toArray(map_1(valueToTagged, value.fields[0])),
+            };
+        case 6:
+            return {
+                kind: "tuple",
+                values: toArray(map_1(valueToTagged, value.fields[0])),
+            };
+        case 7:
+            return {
+                kind: "record",
+                fields: createObj(map_1((tupledArg) => [tupledArg[0], valueToTagged(tupledArg[1])], toList(value.fields[0]))),
+            };
+        case 8:
+            return {
+                kind: "map",
+                entries: toArray(map_1((tupledArg_1) => ({
+                    key: mapKeyToTagged(tupledArg_1[0]),
+                    value: valueToTagged(tupledArg_1[1]),
+                }), toList(value.fields[0]))),
+            };
+        case 9:
+            if (value.fields[0] != null) {
+                const value_7 = value.fields[0];
+                return {
+                    kind: "option",
+                    value: valueToTagged(value_7),
+                };
+            }
+            else {
+                return {
+                    kind: "option",
+                    value: null,
+                };
+            }
+        case 10:
+            return {
+                kind: "union",
+                typeName: value.fields[0],
+                caseName: value.fields[1],
+                value: defaultArg(map(valueToTagged, value.fields[2]), null),
+            };
+        case 11:
+            return {
+                kind: "opaque",
+                valueType: "union-constructor",
+                typeName: value.fields[0],
+                caseName: value.fields[1],
+            };
+        case 12:
+            return {
+                kind: "type",
+                name: Types_typeToString(value.fields[0]),
+            };
+        case 13:
+            return {
+                kind: "opaque",
+                valueType: "task",
+            };
+        case 14:
+            return {
+                kind: "opaque",
+                valueType: "function",
+            };
+        case 15:
+            return {
+                kind: "opaque",
+                valueType: "external",
+                name: value.fields[0].Name,
+                applied: length(value.fields[1]),
+                arity: value.fields[0].Arity,
+            };
+        default:
+            return {
+                kind: "unit",
+            };
+    }
+}
+
+function valueFromJs(value) {
+    let optionValue, payloadValue, payloadValue_1, payloadValue_2;
+    if (typeof value === 'undefined' || value === null) {
+        return new Value(0, []);
+    }
+    else if (Array.isArray(value)) {
+        return new Value(5, [map_1(valueFromJs, ofArray(value))]);
+    }
+    else {
+        const matchValue = typeof value;
+        switch (matchValue) {
+            case "boolean":
+                return new Value(3, [value]);
+            case "bigint":
+                return new Value(1, [value]);
+            case "number":
+                if ((Number.isInteger(value)) && (Number.isSafeInteger(value))) {
+                    return new Value(1, [toInt64_unchecked(fromFloat64(value))]);
+                }
+                else {
+                    return new Value(2, [value]);
+                }
+            case "string":
+                return new Value(4, [value]);
+            case "object": {
+                const matchValue_1 = tryGetProperty("kind", value);
+                if (matchValue_1 == null) {
+                    return new Value(7, [ofList(map_1((name_1) => [name_1, valueFromJs(value[name_1])], ofArray(Object.keys(value))), {
+                        Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+                    })]);
+                }
+                else {
+                    const matchValue_2 = value_18(matchValue_1);
+                    switch (matchValue_2) {
+                        case "unit":
+                            return new Value(0, []);
+                        case "int":
+                            return new Value(1, [int64FromObj(getRequiredProperty("value", value))]);
+                        case "float":
+                            return new Value(2, [getRequiredProperty("value", value)]);
+                        case "bool":
+                            return new Value(3, [getRequiredProperty("value", value)]);
+                        case "string":
+                            return new Value(4, [getRequiredProperty("value", value)]);
+                        case "list":
+                            return new Value(5, [map_1(valueFromJs, ofArray(getRequiredProperty("values", value)))]);
+                        case "tuple":
+                            return new Value(6, [map_1(valueFromJs, ofArray(getRequiredProperty("values", value)))]);
+                        case "record": {
+                            const fields = getRequiredProperty("fields", value);
+                            return new Value(7, [ofList(map_1((name) => [name, valueFromJs(fields[name])], ofArray(Object.keys(fields))), {
+                                Compare: (x, y) => (comparePrimitives(x, y) | 0),
+                            })]);
+                        }
+                        case "map":
+                            return new Value(8, [ofList(map_1((entry) => {
+                                const keyValue = valueFromJs(getRequiredProperty("key", entry));
+                                return [(keyValue.tag === 4) ? (new MapKey(0, [keyValue.fields[0]])) : ((keyValue.tag === 1) ? (new MapKey(1, [keyValue.fields[0]])) : (() => {
+                                    throw new Exception("Map key must be string or int");
+                                })()), valueFromJs(getRequiredProperty("value", entry))];
+                            }, ofArray(getRequiredProperty("entries", value))), {
+                                Compare: (x_1, y_1) => (compare(x_1, y_1) | 0),
+                            })]);
+                        case "option": {
+                            const matchValue_3 = tryGetProperty("value", value);
+                            if (matchValue_3 != null) {
+                                if ((optionValue = value_18(matchValue_3), typeof optionValue === 'undefined' || optionValue === null)) {
+                                    const optionValue_1 = value_18(matchValue_3);
+                                    return new Value(9, [undefined]);
+                                }
+                                else {
+                                    const optionValue_2 = value_18(matchValue_3);
+                                    return new Value(9, [valueFromJs(optionValue_2)]);
+                                }
+                            }
+                            else {
+                                return new Value(9, [undefined]);
+                            }
+                        }
+                        case "union": {
+                            let payload;
+                            const matchValue_4 = tryGetProperty("value", value);
+                            payload = ((matchValue_4 != null) ? (((payloadValue = value_18(matchValue_4), typeof payloadValue === 'undefined' || payloadValue === null)) ? ((payloadValue_1 = value_18(matchValue_4), undefined)) : ((payloadValue_2 = value_18(matchValue_4), valueFromJs(payloadValue_2)))) : undefined);
+                            return new Value(10, [getRequiredProperty("typeName", value), getRequiredProperty("caseName", value), payload]);
+                        }
+                        default:
+                            throw new Exception(concat("Unsupported FScript tagged value kind \'", matchValue_2, "\'"));
+                    }
+                }
+            }
+            default:
+                throw new Exception(concat("Unsupported JavaScript value type \'", matchValue, "\'"));
+        }
+    }
+}
+
+function externsFromArray(value) {
+    if (typeof value === 'undefined' || value === null) {
+        return empty();
+    }
+    else {
+        return ofArray(value);
+    }
+}
+
+function externsFromOptions(options) {
+    const matchValue = tryGetProperty("externs", options);
+    if (matchValue == null) {
+        return empty();
+    }
+    else {
+        return externsFromArray(value_18(matchValue));
+    }
+}
+
+function optionString(name, fallback, options) {
+    const matchValue = tryGetProperty(name, options);
+    if (matchValue == null) {
+        return fallback;
+    }
+    else {
+        return value_18(matchValue);
+    }
+}
+
+function resolverFromOptions(options) {
+    const sourceMap = tryGetProperty("sources", options);
+    const callback = tryGetProperty("resolveImport", options);
+    return (path) => {
+        if (callback == null) {
+            if (sourceMap == null) {
+                return undefined;
+            }
+            else {
+                const sources = value_18(sourceMap);
+                const value_1 = sources[path];
+                return (typeof value_1 === 'undefined' || value_1 === null) ? undefined : value_1;
+            }
+        }
+        else {
+            const resolve = value_18(callback);
+            const value = resolve(path);
+            return (typeof value === 'undefined' || value === null) ? undefined : value;
+        }
+    };
+}
+
+function parseSource(source, options, externs) {
+    return new ParsedProgramHandle("program", parseProgramFromSourceWithIncludesResolver(optionString("rootDirectory", "/", options), optionString("entryFile", "/main.fss", options), source, resolverFromOptions(options)), externs);
+}
+
+function isCallable(value) {
+    switch (value.tag) {
+        case 14:
+        case 15:
+        case 11:
+            return true;
+        default:
+            return false;
+    }
+}
+
+function declaredExportedNames(program) {
+    return collect((_arg) => {
+        let matchResult, isExported_2, name_1, bindings_1, isExported_3;
+        switch (_arg.tag) {
+            case 1: {
+                if (_arg.fields[4]) {
+                    matchResult = 0;
+                    isExported_2 = _arg.fields[4];
+                    name_1 = _arg.fields[0];
+                }
+                else {
+                    matchResult = 2;
+                }
+                break;
+            }
+            case 3: {
+                if (_arg.fields[1]) {
+                    matchResult = 1;
+                    bindings_1 = _arg.fields[0];
+                    isExported_3 = _arg.fields[1];
+                }
+                else {
+                    matchResult = 2;
+                }
+                break;
+            }
+            default:
+                matchResult = 2;
+        }
+        switch (matchResult) {
+            case 0:
+                return singleton(name_1);
+            case 1:
+                return map_1((tupledArg) => tupledArg[0], bindings_1);
+            default:
+                return empty();
+        }
+    }, program);
+}
+
+function hasExpression(statements) {
+    return exists((_arg) => {
+        if (_arg.tag === 5) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, statements);
+}
+
+function retainedStatements(statements) {
+    return filter((_arg) => {
+        if (_arg.tag === 5) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }, statements);
+}
+
+function loadTyped(typed, externs) {
+    const state = evalProgramWithExternsState(externs, typed);
+    const exportedNames = sort(List_distinct(declaredExportedNames(typed), {
+        Equals: (x, y) => (x === y),
+        GetHashCode: (x) => (stringHash(x) | 0),
+    }), {
+        Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+    });
+    const functionNames = filter((name) => {
+        const matchValue = FSharpMap__TryFind(state.Env, name);
+        if (matchValue == null) {
+            return false;
+        }
+        else {
+            return isCallable(matchValue);
+        }
+    }, exportedNames);
+    const functionSet = ofList_1(functionNames, {
+        Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+    });
+    const functions = ofList(choose((name_1) => map((value_1) => [name_1, value_1], FSharpMap__TryFind(state.Env, name_1)), functionNames), {
+        Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
+    });
+    const valueNames = filter((name_2) => {
+        const matchValue_1 = FSharpMap__TryFind(state.Env, name_2);
+        if (matchValue_1 == null) {
+            return false;
+        }
+        else {
+            return !isCallable(matchValue_1);
+        }
+    }, exportedNames);
+    return new LoadedScriptHandle("loaded", state.TypeDefs, state.Env, functionNames, functionSet, functions, valueNames, ofList_1(valueNames, {
+        Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+    }), ofList(choose((name_3) => map((value_3) => [name_3, value_3], FSharpMap__TryFind(state.Env, name_3)), valueNames), {
+        Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
+    }), state.LastValue, externs);
+}
+
+export function parse(source, options) {
+    return withStructuredErrors(() => parseSource(source, options, externsFromOptions(options)));
+}
+
+export function infer(program, externs) {
+    return withStructuredErrors(() => {
+        const parsed = program;
+        const externs_1 = (typeof externs === 'undefined' || externs === null) ? parsed.externs : externsFromArray(externs);
+        return new TypedProgramHandle("typedProgram", inferProgramWithExterns(externs_1, parsed.program), externs_1);
+    });
+}
+
+export function evaluate(typedProgram, externs) {
+    return withStructuredErrors(() => {
+        const typed = typedProgram;
+        return valueToTagged(evalProgramWithExterns((typeof externs === 'undefined' || externs === null) ? typed.externs : externsFromArray(externs), typed.typedProgram));
+    });
+}
+
+export function load(source, options) {
+    return withStructuredErrors(() => {
+        const externs = externsFromOptions(options);
+        return loadTyped(inferProgramWithExterns(externs, parseSource(source, options, externs).program), externs);
+    });
+}
+
+export function run(source, options) {
+    return withStructuredErrors(() => valueToTagged(load(source, options).lastValue));
+}
+
+export function createSession(options) {
+    return withStructuredErrors(() => (new SessionHandle("session", empty(), options, externsFromOptions(options))));
+}
+
+export function resetSession(session) {
+    return withStructuredErrors(() => {
+        const session_1 = session;
+        session_1.retainedProgram = empty();
+        return session_1;
+    });
+}
+
+export function submit(session, source) {
+    return withStructuredErrors(() => {
+        const session_1 = session;
+        const parsed = parseSource(source, session_1.options, session_1.externs);
+        const state = evalProgramWithExternsState(session_1.externs, inferProgramWithExterns(session_1.externs, append(session_1.retainedProgram, parsed.program)));
+        const submittedHasExpression = hasExpression(parsed.program);
+        session_1.retainedProgram = append(session_1.retainedProgram, retainedStatements(parsed.program));
+        return {
+            kind: "session-result",
+            hasValue: submittedHasExpression,
+            value: submittedHasExpression ? valueToTagged(state.LastValue) : (null),
+            text: submittedHasExpression ? valueToString(state.LastValue) : "",
+            retainedCount: length(session_1.retainedProgram),
+        };
+    });
+}
+
+export function listFunctions(loaded) {
+    return withStructuredErrors(() => toArray(loaded.exportedFunctionNames));
+}
+
+export function listValues(loaded) {
+    return withStructuredErrors(() => toArray(loaded.exportedValueNames));
+}
+
+export function getValue(loaded, name) {
+    return withStructuredErrors(() => {
+        const loaded_1 = loaded;
+        if (!FSharpSet__Contains(loaded_1.exportedValueSet, name)) {
+            throw new EvalException(new EvalError$(concat("Unknown exported value \'", name, "\'"), new Span(new Position(undefined, 0, 0), new Position(undefined, 0, 0))));
+        }
+        return valueToTagged(FSharpMap__get_Item(loaded_1.exportedValues, name));
+    });
+}
+
+export function invoke(loaded, name, args) {
+    return withStructuredErrors(() => {
+        const loaded_1 = loaded;
+        if (!FSharpSet__Contains(loaded_1.exportedFunctionSet, name)) {
+            if (FSharpSet__Contains(loaded_1.exportedValueSet, name)) {
+                throw new EvalException(new EvalError$(concat("\'", name, "\' is a value and cannot be invoked"), new Span(new Position(undefined, 0, 0), new Position(undefined, 0, 0))));
+            }
+            else {
+                throw new EvalException(new EvalError$(concat("Unknown exported function \'", name, "\'"), new Span(new Position(undefined, 0, 0), new Position(undefined, 0, 0))));
+            }
+        }
+        return valueToTagged(invokeValue(loaded_1.typeDefs, FSharpMap__get_Item(loaded_1.exportedFunctions, name), (typeof args === 'undefined' || args === null) ? empty() : map_1(valueFromJs, ofArray(args))));
+    });
+}
+
+export function formatValue(value) {
+    return withStructuredErrors(() => valueToString(valueFromJs(value)));
+}
+
+export function toJs(value) {
+    return withStructuredErrors(() => valueToTagged(value));
+}
+
+export function fromJs(value, _expectedType) {
+    return withStructuredErrors(() => valueFromJs(value));
+}
+
+export const T = {
+    unit: new Type(0, []),
+    int: new Type(1, []),
+    float: new Type(2, []),
+    bool: new Type(3, []),
+    string: new Type(4, []),
+    typeToken: new Type(14, []),
+    var: (value) => (new Type(15, [intFromObj(value)])),
+    list: (value_1) => (new Type(5, [value_1])),
+    task: (value_2) => (new Type(6, [value_2])),
+    option: (value_3) => (new Type(10, [value_3])),
+    map: (value_4) => (new Type(9, [new Type(4, []), value_4])),
+    tuple: (values) => (new Type(7, [map_1((value_6) => value_6, ofArray(values))])),
+    record: (fields) => (new Type(8, [ofList(map_1((name) => [name, fields[name]], ofArray(Object.keys(fields))), {
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    })])),
+    func: (left, right) => (new Type(11, [left, right])),
+    scheme: (value_8) => (new Scheme(empty(), value_8)),
+    forall: (vars, value_9) => (new Scheme(map_1((value_11) => (intFromObj(value_11) | 0), ofArray(vars)), value_9)),
+};
+
+export function extern(definition) {
+    return withStructuredErrors(() => {
+        const name = getRequiredProperty("name", definition);
+        const arity = intFromObj(getRequiredProperty("arity", definition)) | 0;
+        const scheme = getRequiredProperty("scheme", definition);
+        const invoke_1 = getRequiredProperty("invoke", definition);
+        return new ExternalFunction(name, scheme, (_arg, args) => {
+            let _arg_1;
+            return valueFromJs((_arg_1 = toArray(map_1(valueToTagged, args)), invoke_1(_arg_1)));
+        }, arity);
+    });
+}
+