@nfdi4plants/arctrl 1.0.0-alpha10

package/fable_modules/fable-library.4.1.4/Char.js

@@ -0,0 +1,169 @@
+import * as Unicode from "./Unicode.13.0.0.js";
+function getCategoryFunc() {
+    // unpack Unicode codepoint ranges (delta encoded) and general categories
+    const offset = 35; // offsets unprintable characters
+    const a1 = [...Unicode.rangeDeltas].map((ch) => (ch.codePointAt(0) ?? 0) - offset);
+    const a2 = [...Unicode.categories].map((ch) => (ch.codePointAt(0) ?? 0) - offset);
+    const codepoints = new Uint32Array(a1);
+    const categories = new Uint8Array(a2);
+    for (let i = 1; i < codepoints.length; ++i) {
+        codepoints[i] += codepoints[i - 1];
+    }
+    // binary search in unicode ranges
+    return (cp) => {
+        let hi = codepoints.length;
+        let lo = 0;
+        while (hi - lo > 1) {
+            const mid = Math.floor((hi + lo) / 2);
+            const test = codepoints[mid];
+            if (cp < test) {
+                hi = mid;
+            }
+            else if (cp === test) {
+                hi = lo = mid;
+                break;
+            }
+            else if (test < cp) {
+                lo = mid;
+            }
+        }
+        return categories[lo];
+    };
+}
+const isControlMask = 1 << 14 /* UnicodeCategory.Control */;
+const isDigitMask = 1 << 8 /* UnicodeCategory.DecimalDigitNumber */;
+const isLetterMask = 0
+    | 1 << 0 /* UnicodeCategory.UppercaseLetter */
+    | 1 << 1 /* UnicodeCategory.LowercaseLetter */
+    | 1 << 2 /* UnicodeCategory.TitlecaseLetter */
+    | 1 << 3 /* UnicodeCategory.ModifierLetter */
+    | 1 << 4 /* UnicodeCategory.OtherLetter */;
+const isLetterOrDigitMask = isLetterMask | isDigitMask;
+const isUpperMask = 1 << 0 /* UnicodeCategory.UppercaseLetter */;
+const isLowerMask = 1 << 1 /* UnicodeCategory.LowercaseLetter */;
+const isNumberMask = 0
+    | 1 << 8 /* UnicodeCategory.DecimalDigitNumber */
+    | 1 << 9 /* UnicodeCategory.LetterNumber */
+    | 1 << 10 /* UnicodeCategory.OtherNumber */;
+const isPunctuationMask = 0
+    | 1 << 18 /* UnicodeCategory.ConnectorPunctuation */
+    | 1 << 19 /* UnicodeCategory.DashPunctuation */
+    | 1 << 20 /* UnicodeCategory.OpenPunctuation */
+    | 1 << 21 /* UnicodeCategory.ClosePunctuation */
+    | 1 << 22 /* UnicodeCategory.InitialQuotePunctuation */
+    | 1 << 23 /* UnicodeCategory.FinalQuotePunctuation */
+    | 1 << 24 /* UnicodeCategory.OtherPunctuation */;
+const isSeparatorMask = 0
+    | 1 << 11 /* UnicodeCategory.SpaceSeparator */
+    | 1 << 12 /* UnicodeCategory.LineSeparator */
+    | 1 << 13 /* UnicodeCategory.ParagraphSeparator */;
+const isSymbolMask = 0
+    | 1 << 25 /* UnicodeCategory.MathSymbol */
+    | 1 << 26 /* UnicodeCategory.CurrencySymbol */
+    | 1 << 27 /* UnicodeCategory.ModifierSymbol */
+    | 1 << 28 /* UnicodeCategory.OtherSymbol */;
+const isWhiteSpaceMask = 0
+    | 1 << 11 /* UnicodeCategory.SpaceSeparator */
+    | 1 << 12 /* UnicodeCategory.LineSeparator */
+    | 1 << 13 /* UnicodeCategory.ParagraphSeparator */;
+const unicodeCategoryFunc = getCategoryFunc();
+function charCodeAt(s, index) {
+    if (index >= 0 && index < s.length) {
+        return s.charCodeAt(index);
+    }
+    else {
+        throw new Error("Index out of range.");
+    }
+}
+export const getUnicodeCategory = (s) => getUnicodeCategory2(s, 0);
+export const isControl = (s) => isControl2(s, 0);
+export const isDigit = (s) => isDigit2(s, 0);
+export const isLetter = (s) => isLetter2(s, 0);
+export const isLetterOrDigit = (s) => isLetterOrDigit2(s, 0);
+export const isUpper = (s) => isUpper2(s, 0);
+export const isLower = (s) => isLower2(s, 0);
+export const isNumber = (s) => isNumber2(s, 0);
+export const isPunctuation = (s) => isPunctuation2(s, 0);
+export const isSeparator = (s) => isSeparator2(s, 0);
+export const isSymbol = (s) => isSymbol2(s, 0);
+export const isWhiteSpace = (s) => isWhiteSpace2(s, 0);
+export const isHighSurrogate = (s) => isHighSurrogate2(s, 0);
+export const isLowSurrogate = (s) => isLowSurrogate2(s, 0);
+export const isSurrogate = (s) => isSurrogate2(s, 0);
+export function getUnicodeCategory2(s, index) {
+    const cp = charCodeAt(s, index);
+    return unicodeCategoryFunc(cp);
+}
+export function isControl2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isControlMask) !== 0;
+}
+export function isDigit2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isDigitMask) !== 0;
+}
+export function isLetter2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLetterMask) !== 0;
+}
+export function isLetterOrDigit2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLetterOrDigitMask) !== 0;
+}
+export function isUpper2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isUpperMask) !== 0;
+}
+export function isLower2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLowerMask) !== 0;
+}
+export function isNumber2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isNumberMask) !== 0;
+}
+export function isPunctuation2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isPunctuationMask) !== 0;
+}
+export function isSeparator2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isSeparatorMask) !== 0;
+}
+export function isSymbol2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isSymbolMask) !== 0;
+}
+export function isWhiteSpace2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    if ((test & isWhiteSpaceMask) !== 0) {
+        return true;
+    }
+    const cp = charCodeAt(s, index);
+    return (0x09 <= cp && cp <= 0x0D) || cp === 0x85 || cp === 0xA0;
+}
+export function isHighSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xD800 <= cp && cp <= 0xDBFF);
+}
+export function isLowSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xDC00 <= cp && cp <= 0xDFFF);
+}
+export function isSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xD800 <= cp && cp <= 0xDFFF);
+}
+export function isSurrogatePair(s, index) {
+    return typeof index === "number"
+        ? isHighSurrogate2(s, index) && isLowSurrogate2(s, index + 1)
+        : isHighSurrogate(s) && isLowSurrogate(index);
+}
+export function parse(input) {
+    if (input.length === 1) {
+        return input[0];
+    }
+    else {
+        throw new Error("String must be exactly one character long.");
+    }
+}

package/fable_modules/fable-library.4.1.4/Choice.d.ts

@@ -0,0 +1,138 @@
+import { Union } from "./Types.js";
+import { TypeInfo } from "./Reflection.js";
+import { Option } from "./Option.js";
+export type FSharpResult$2_$union<T, TError> = FSharpResult$2<T, TError, 0> | FSharpResult$2<T, TError, 1>;
+export type FSharpResult$2_$cases<T, TError> = {
+    0: ["Ok", [T]];
+    1: ["Error", [TError]];
+};
+export declare function FSharpResult$2_Ok<T, TError>(ResultValue: T): FSharpResult$2<T, TError, 0>;
+export declare function FSharpResult$2_Error<T, TError>(ErrorValue: TError): FSharpResult$2<T, TError, 1>;
+export declare class FSharpResult$2<T, TError, Tag extends keyof FSharpResult$2_$cases<T, TError>> extends Union<Tag, FSharpResult$2_$cases<T, TError>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpResult$2_$cases<T, TError>[Tag][1];
+    constructor(tag: Tag, fields: FSharpResult$2_$cases<T, TError>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpResult$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
+export declare function Result_Map<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
+export declare function Result_MapError<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<c, a>): FSharpResult$2_$union<c, b>;
+export declare function Result_Bind<a, b, c>(binder: ((arg0: a) => FSharpResult$2_$union<b, c>), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
+export type FSharpChoice$2_$union<T1, T2> = FSharpChoice$2<T1, T2, 0> | FSharpChoice$2<T1, T2, 1>;
+export type FSharpChoice$2_$cases<T1, T2> = {
+    0: ["Choice1Of2", [T1]];
+    1: ["Choice2Of2", [T2]];
+};
+export declare function FSharpChoice$2_Choice1Of2<T1, T2>(Item: T1): FSharpChoice$2<T1, T2, 0>;
+export declare function FSharpChoice$2_Choice2Of2<T1, T2>(Item: T2): FSharpChoice$2<T1, T2, 1>;
+export declare class FSharpChoice$2<T1, T2, Tag extends keyof FSharpChoice$2_$cases<T1, T2>> extends Union<Tag, FSharpChoice$2_$cases<T1, T2>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpChoice$2_$cases<T1, T2>[Tag][1];
+    constructor(tag: Tag, fields: FSharpChoice$2_$cases<T1, T2>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpChoice$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
+export type FSharpChoice$3_$union<T1, T2, T3> = FSharpChoice$3<T1, T2, T3, 0> | FSharpChoice$3<T1, T2, T3, 1> | FSharpChoice$3<T1, T2, T3, 2>;
+export type FSharpChoice$3_$cases<T1, T2, T3> = {
+    0: ["Choice1Of3", [T1]];
+    1: ["Choice2Of3", [T2]];
+    2: ["Choice3Of3", [T3]];
+};
+export declare function FSharpChoice$3_Choice1Of3<T1, T2, T3>(Item: T1): FSharpChoice$3<T1, T2, T3, 0>;
+export declare function FSharpChoice$3_Choice2Of3<T1, T2, T3>(Item: T2): FSharpChoice$3<T1, T2, T3, 1>;
+export declare function FSharpChoice$3_Choice3Of3<T1, T2, T3>(Item: T3): FSharpChoice$3<T1, T2, T3, 2>;
+export declare class FSharpChoice$3<T1, T2, T3, Tag extends keyof FSharpChoice$3_$cases<T1, T2, T3>> extends Union<Tag, FSharpChoice$3_$cases<T1, T2, T3>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpChoice$3_$cases<T1, T2, T3>[Tag][1];
+    constructor(tag: Tag, fields: FSharpChoice$3_$cases<T1, T2, T3>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpChoice$3_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo): TypeInfo;
+export type FSharpChoice$4_$union<T1, T2, T3, T4> = FSharpChoice$4<T1, T2, T3, T4, 0> | FSharpChoice$4<T1, T2, T3, T4, 1> | FSharpChoice$4<T1, T2, T3, T4, 2> | FSharpChoice$4<T1, T2, T3, T4, 3>;
+export type FSharpChoice$4_$cases<T1, T2, T3, T4> = {
+    0: ["Choice1Of4", [T1]];
+    1: ["Choice2Of4", [T2]];
+    2: ["Choice3Of4", [T3]];
+    3: ["Choice4Of4", [T4]];
+};
+export declare function FSharpChoice$4_Choice1Of4<T1, T2, T3, T4>(Item: T1): FSharpChoice$4<T1, T2, T3, T4, 0>;
+export declare function FSharpChoice$4_Choice2Of4<T1, T2, T3, T4>(Item: T2): FSharpChoice$4<T1, T2, T3, T4, 1>;
+export declare function FSharpChoice$4_Choice3Of4<T1, T2, T3, T4>(Item: T3): FSharpChoice$4<T1, T2, T3, T4, 2>;
+export declare function FSharpChoice$4_Choice4Of4<T1, T2, T3, T4>(Item: T4): FSharpChoice$4<T1, T2, T3, T4, 3>;
+export declare class FSharpChoice$4<T1, T2, T3, T4, Tag extends keyof FSharpChoice$4_$cases<T1, T2, T3, T4>> extends Union<Tag, FSharpChoice$4_$cases<T1, T2, T3, T4>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpChoice$4_$cases<T1, T2, T3, T4>[Tag][1];
+    constructor(tag: Tag, fields: FSharpChoice$4_$cases<T1, T2, T3, T4>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpChoice$4_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo): TypeInfo;
+export type FSharpChoice$5_$union<T1, T2, T3, T4, T5> = FSharpChoice$5<T1, T2, T3, T4, T5, 0> | FSharpChoice$5<T1, T2, T3, T4, T5, 1> | FSharpChoice$5<T1, T2, T3, T4, T5, 2> | FSharpChoice$5<T1, T2, T3, T4, T5, 3> | FSharpChoice$5<T1, T2, T3, T4, T5, 4>;
+export type FSharpChoice$5_$cases<T1, T2, T3, T4, T5> = {
+    0: ["Choice1Of5", [T1]];
+    1: ["Choice2Of5", [T2]];
+    2: ["Choice3Of5", [T3]];
+    3: ["Choice4Of5", [T4]];
+    4: ["Choice5Of5", [T5]];
+};
+export declare function FSharpChoice$5_Choice1Of5<T1, T2, T3, T4, T5>(Item: T1): FSharpChoice$5<T1, T2, T3, T4, T5, 0>;
+export declare function FSharpChoice$5_Choice2Of5<T1, T2, T3, T4, T5>(Item: T2): FSharpChoice$5<T1, T2, T3, T4, T5, 1>;
+export declare function FSharpChoice$5_Choice3Of5<T1, T2, T3, T4, T5>(Item: T3): FSharpChoice$5<T1, T2, T3, T4, T5, 2>;
+export declare function FSharpChoice$5_Choice4Of5<T1, T2, T3, T4, T5>(Item: T4): FSharpChoice$5<T1, T2, T3, T4, T5, 3>;
+export declare function FSharpChoice$5_Choice5Of5<T1, T2, T3, T4, T5>(Item: T5): FSharpChoice$5<T1, T2, T3, T4, T5, 4>;
+export declare class FSharpChoice$5<T1, T2, T3, T4, T5, Tag extends keyof FSharpChoice$5_$cases<T1, T2, T3, T4, T5>> extends Union<Tag, FSharpChoice$5_$cases<T1, T2, T3, T4, T5>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpChoice$5_$cases<T1, T2, T3, T4, T5>[Tag][1];
+    constructor(tag: Tag, fields: FSharpChoice$5_$cases<T1, T2, T3, T4, T5>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpChoice$5_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo): TypeInfo;
+export type FSharpChoice$6_$union<T1, T2, T3, T4, T5, T6> = FSharpChoice$6<T1, T2, T3, T4, T5, T6, 0> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 1> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 2> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 3> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 4> | FSharpChoice$6<T1, T2, T3, T4, T5, T6, 5>;
+export type FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6> = {
+    0: ["Choice1Of6", [T1]];
+    1: ["Choice2Of6", [T2]];
+    2: ["Choice3Of6", [T3]];
+    3: ["Choice4Of6", [T4]];
+    4: ["Choice5Of6", [T5]];
+    5: ["Choice6Of6", [T6]];
+};
+export declare function FSharpChoice$6_Choice1Of6<T1, T2, T3, T4, T5, T6>(Item: T1): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 0>;
+export declare function FSharpChoice$6_Choice2Of6<T1, T2, T3, T4, T5, T6>(Item: T2): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 1>;
+export declare function FSharpChoice$6_Choice3Of6<T1, T2, T3, T4, T5, T6>(Item: T3): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 2>;
+export declare function FSharpChoice$6_Choice4Of6<T1, T2, T3, T4, T5, T6>(Item: T4): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 3>;
+export declare function FSharpChoice$6_Choice5Of6<T1, T2, T3, T4, T5, T6>(Item: T5): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 4>;
+export declare function FSharpChoice$6_Choice6Of6<T1, T2, T3, T4, T5, T6>(Item: T6): FSharpChoice$6<T1, T2, T3, T4, T5, T6, 5>;
+export declare class FSharpChoice$6<T1, T2, T3, T4, T5, T6, Tag extends keyof FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>> extends Union<Tag, FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>[Tag][1];
+    constructor(tag: Tag, fields: FSharpChoice$6_$cases<T1, T2, T3, T4, T5, T6>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpChoice$6_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo, gen5: TypeInfo): TypeInfo;
+export type FSharpChoice$7_$union<T1, T2, T3, T4, T5, T6, T7> = FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 0> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 1> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 2> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 3> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 4> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 5> | FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 6>;
+export type FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7> = {
+    0: ["Choice1Of7", [T1]];
+    1: ["Choice2Of7", [T2]];
+    2: ["Choice3Of7", [T3]];
+    3: ["Choice4Of7", [T4]];
+    4: ["Choice5Of7", [T5]];
+    5: ["Choice6Of7", [T6]];
+    6: ["Choice7Of7", [T7]];
+};
+export declare function FSharpChoice$7_Choice1Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T1): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 0>;
+export declare function FSharpChoice$7_Choice2Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T2): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 1>;
+export declare function FSharpChoice$7_Choice3Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T3): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 2>;
+export declare function FSharpChoice$7_Choice4Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T4): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 3>;
+export declare function FSharpChoice$7_Choice5Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T5): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 4>;
+export declare function FSharpChoice$7_Choice6Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T6): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 5>;
+export declare function FSharpChoice$7_Choice7Of7<T1, T2, T3, T4, T5, T6, T7>(Item: T7): FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, 6>;
+export declare class FSharpChoice$7<T1, T2, T3, T4, T5, T6, T7, Tag extends keyof FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>> extends Union<Tag, FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>[Tag][1];
+    constructor(tag: Tag, fields: FSharpChoice$7_$cases<T1, T2, T3, T4, T5, T6, T7>[Tag][1]);
+    cases(): string[];
+}
+export declare function FSharpChoice$7_$reflection(gen0: TypeInfo, gen1: TypeInfo, gen2: TypeInfo, gen3: TypeInfo, gen4: TypeInfo, gen5: TypeInfo, gen6: TypeInfo): TypeInfo;
+export declare function Choice_makeChoice1Of2<T1, a>(x: T1): FSharpChoice$2_$union<T1, a>;
+export declare function Choice_makeChoice2Of2<T2, a>(x: T2): FSharpChoice$2_$union<a, T2>;
+export declare function Choice_tryValueIfChoice1Of2<T1, T2>(x: FSharpChoice$2_$union<T1, T2>): Option<T1>;
+export declare function Choice_tryValueIfChoice2Of2<T1, T2>(x: FSharpChoice$2_$union<T1, T2>): Option<T2>;

package/fable_modules/fable-library.4.1.4/Choice.js

@@ -0,0 +1,227 @@
+import { Union } from "./Types.js";
+import { union_type } from "./Reflection.js";
+import { some } from "./Option.js";
+export function FSharpResult$2_Ok(ResultValue) {
+    return new FSharpResult$2(0, [ResultValue]);
+}
+export function FSharpResult$2_Error(ErrorValue) {
+    return new FSharpResult$2(1, [ErrorValue]);
+}
+export class FSharpResult$2 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Ok", "Error"];
+    }
+}
+export function FSharpResult$2_$reflection(gen0, gen1) {
+    return union_type("FSharp.Core.FSharpResult`2", [gen0, gen1], FSharpResult$2, () => [[["ResultValue", gen0]], [["ErrorValue", gen1]]]);
+}
+export function Result_Map(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(mapping(result.fields[0]));
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+export function Result_MapError(mapping, result) {
+    if (result.tag === /* Ok */ 0) {
+        return FSharpResult$2_Ok(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(mapping(result.fields[0]));
+    }
+}
+export function Result_Bind(binder, result) {
+    if (result.tag === /* Ok */ 0) {
+        return binder(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+export function FSharpChoice$2_Choice1Of2(Item) {
+    return new FSharpChoice$2(0, [Item]);
+}
+export function FSharpChoice$2_Choice2Of2(Item) {
+    return new FSharpChoice$2(1, [Item]);
+}
+export class FSharpChoice$2 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Choice1Of2", "Choice2Of2"];
+    }
+}
+export function FSharpChoice$2_$reflection(gen0, gen1) {
+    return union_type("FSharp.Core.FSharpChoice`2", [gen0, gen1], FSharpChoice$2, () => [[["Item", gen0]], [["Item", gen1]]]);
+}
+export function FSharpChoice$3_Choice1Of3(Item) {
+    return new FSharpChoice$3(0, [Item]);
+}
+export function FSharpChoice$3_Choice2Of3(Item) {
+    return new FSharpChoice$3(1, [Item]);
+}
+export function FSharpChoice$3_Choice3Of3(Item) {
+    return new FSharpChoice$3(2, [Item]);
+}
+export class FSharpChoice$3 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Choice1Of3", "Choice2Of3", "Choice3Of3"];
+    }
+}
+export function FSharpChoice$3_$reflection(gen0, gen1, gen2) {
+    return union_type("FSharp.Core.FSharpChoice`3", [gen0, gen1, gen2], FSharpChoice$3, () => [[["Item", gen0]], [["Item", gen1]], [["Item", gen2]]]);
+}
+export function FSharpChoice$4_Choice1Of4(Item) {
+    return new FSharpChoice$4(0, [Item]);
+}
+export function FSharpChoice$4_Choice2Of4(Item) {
+    return new FSharpChoice$4(1, [Item]);
+}
+export function FSharpChoice$4_Choice3Of4(Item) {
+    return new FSharpChoice$4(2, [Item]);
+}
+export function FSharpChoice$4_Choice4Of4(Item) {
+    return new FSharpChoice$4(3, [Item]);
+}
+export class FSharpChoice$4 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Choice1Of4", "Choice2Of4", "Choice3Of4", "Choice4Of4"];
+    }
+}
+export function FSharpChoice$4_$reflection(gen0, gen1, gen2, gen3) {
+    return union_type("FSharp.Core.FSharpChoice`4", [gen0, gen1, gen2, gen3], FSharpChoice$4, () => [[["Item", gen0]], [["Item", gen1]], [["Item", gen2]], [["Item", gen3]]]);
+}
+export function FSharpChoice$5_Choice1Of5(Item) {
+    return new FSharpChoice$5(0, [Item]);
+}
+export function FSharpChoice$5_Choice2Of5(Item) {
+    return new FSharpChoice$5(1, [Item]);
+}
+export function FSharpChoice$5_Choice3Of5(Item) {
+    return new FSharpChoice$5(2, [Item]);
+}
+export function FSharpChoice$5_Choice4Of5(Item) {
+    return new FSharpChoice$5(3, [Item]);
+}
+export function FSharpChoice$5_Choice5Of5(Item) {
+    return new FSharpChoice$5(4, [Item]);
+}
+export class FSharpChoice$5 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Choice1Of5", "Choice2Of5", "Choice3Of5", "Choice4Of5", "Choice5Of5"];
+    }
+}
+export function FSharpChoice$5_$reflection(gen0, gen1, gen2, gen3, gen4) {
+    return union_type("FSharp.Core.FSharpChoice`5", [gen0, gen1, gen2, gen3, gen4], FSharpChoice$5, () => [[["Item", gen0]], [["Item", gen1]], [["Item", gen2]], [["Item", gen3]], [["Item", gen4]]]);
+}
+export function FSharpChoice$6_Choice1Of6(Item) {
+    return new FSharpChoice$6(0, [Item]);
+}
+export function FSharpChoice$6_Choice2Of6(Item) {
+    return new FSharpChoice$6(1, [Item]);
+}
+export function FSharpChoice$6_Choice3Of6(Item) {
+    return new FSharpChoice$6(2, [Item]);
+}
+export function FSharpChoice$6_Choice4Of6(Item) {
+    return new FSharpChoice$6(3, [Item]);
+}
+export function FSharpChoice$6_Choice5Of6(Item) {
+    return new FSharpChoice$6(4, [Item]);
+}
+export function FSharpChoice$6_Choice6Of6(Item) {
+    return new FSharpChoice$6(5, [Item]);
+}
+export class FSharpChoice$6 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Choice1Of6", "Choice2Of6", "Choice3Of6", "Choice4Of6", "Choice5Of6", "Choice6Of6"];
+    }
+}
+export function FSharpChoice$6_$reflection(gen0, gen1, gen2, gen3, gen4, gen5) {
+    return union_type("FSharp.Core.FSharpChoice`6", [gen0, gen1, gen2, gen3, gen4, gen5], FSharpChoice$6, () => [[["Item", gen0]], [["Item", gen1]], [["Item", gen2]], [["Item", gen3]], [["Item", gen4]], [["Item", gen5]]]);
+}
+export function FSharpChoice$7_Choice1Of7(Item) {
+    return new FSharpChoice$7(0, [Item]);
+}
+export function FSharpChoice$7_Choice2Of7(Item) {
+    return new FSharpChoice$7(1, [Item]);
+}
+export function FSharpChoice$7_Choice3Of7(Item) {
+    return new FSharpChoice$7(2, [Item]);
+}
+export function FSharpChoice$7_Choice4Of7(Item) {
+    return new FSharpChoice$7(3, [Item]);
+}
+export function FSharpChoice$7_Choice5Of7(Item) {
+    return new FSharpChoice$7(4, [Item]);
+}
+export function FSharpChoice$7_Choice6Of7(Item) {
+    return new FSharpChoice$7(5, [Item]);
+}
+export function FSharpChoice$7_Choice7Of7(Item) {
+    return new FSharpChoice$7(6, [Item]);
+}
+export class FSharpChoice$7 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Choice1Of7", "Choice2Of7", "Choice3Of7", "Choice4Of7", "Choice5Of7", "Choice6Of7", "Choice7Of7"];
+    }
+}
+export function FSharpChoice$7_$reflection(gen0, gen1, gen2, gen3, gen4, gen5, gen6) {
+    return union_type("FSharp.Core.FSharpChoice`7", [gen0, gen1, gen2, gen3, gen4, gen5, gen6], FSharpChoice$7, () => [[["Item", gen0]], [["Item", gen1]], [["Item", gen2]], [["Item", gen3]], [["Item", gen4]], [["Item", gen5]], [["Item", gen6]]]);
+}
+export function Choice_makeChoice1Of2(x) {
+    return FSharpChoice$2_Choice1Of2(x);
+}
+export function Choice_makeChoice2Of2(x) {
+    return FSharpChoice$2_Choice2Of2(x);
+}
+export function Choice_tryValueIfChoice1Of2(x) {
+    if (x.tag === /* Choice1Of2 */ 0) {
+        return some(x.fields[0]);
+    }
+    else {
+        return void 0;
+    }
+}
+export function Choice_tryValueIfChoice2Of2(x) {
+    if (x.tag === /* Choice2Of2 */ 1) {
+        return some(x.fields[0]);
+    }
+    else {
+        return void 0;
+    }
+}

package/fable_modules/fable-library.4.1.4/Date.d.ts

@@ -0,0 +1,70 @@
+/**
+ * DateTimeOffset functions.
+ *
+ * Note: Date instances are always DateObjects in local
+ * timezone (because JS dates are all kinds of messed up).
+ * A local date returns UTC epoch when `.getTime()` is called.
+ *
+ * Basically; invariant: date.getTime() always return UTC time.
+ */
+import { int64 } from "./BigInt.js";
+import { FSharpRef } from "./Types.js";
+import { compareDates, DateKind, IDateTime, IDateTimeOffset } from "./Util.js";
+export type OffsetInMinutes = number;
+export type Offset = "Z" | OffsetInMinutes | null;
+export declare function kind(value: IDateTime): number;
+export declare function unixEpochMillisecondsToTicks(ms: number, offset: number): int64;
+export declare function ticksToUnixEpochMilliseconds(ticks: number | bigint): number;
+export declare function dateOffsetToString(offset: number): string;
+export declare function dateToHalfUTCString(date: IDateTime, half: "first" | "second"): string;
+export declare function toString(date: IDateTime | IDateTimeOffset, format?: string, _provider?: any): string;
+export declare function DateTime(value: number, kind?: DateKind): IDateTime;
+export declare function fromTicks(ticks: number | bigint, kind?: DateKind): IDateTime;
+export declare function fromDateTimeOffset(date: IDateTimeOffset, kind: DateKind): IDateTime;
+export declare function getTicks(date: IDateTime | IDateTimeOffset): bigint;
+export declare function minValue(): IDateTime;
+export declare function maxValue(): IDateTime;
+export declare function parseRaw(input: string): [Date, Offset];
+export declare function parse(str: string, detectUTC?: boolean): IDateTime;
+export declare function tryParse(v: string, defValue: FSharpRef<IDateTime>): boolean;
+export declare function create(year: number, month: number, day: number, h?: number, m?: number, s?: number, ms?: number, kind?: DateKind): IDateTime;
+export declare function now(): IDateTime;
+export declare function utcNow(): IDateTime;
+export declare function today(): IDateTime;
+export declare function isLeapYear(year: number): boolean;
+export declare function daysInMonth(year: number, month: number): 29 | 28 | 31 | 30;
+export declare function toUniversalTime(date: IDateTime): IDateTime;
+export declare function toLocalTime(date: IDateTime): IDateTime;
+export declare function specifyKind(d: IDateTime, kind: DateKind): IDateTime;
+export declare function timeOfDay(d: IDateTime): number;
+export declare function date(d: IDateTime): IDateTime;
+export declare function day(d: IDateTime): number;
+export declare function hour(d: IDateTime): number;
+export declare function millisecond(d: IDateTime): number;
+export declare function minute(d: IDateTime): number;
+export declare function month(d: IDateTime): number;
+export declare function second(d: IDateTime): number;
+export declare function year(d: IDateTime): number;
+export declare function dayOfWeek(d: IDateTime): number;
+export declare function dayOfYear(d: IDateTime): number;
+export declare function add(d: IDateTime, ts: number): IDateTime;
+export declare function addDays(d: IDateTime, v: number): IDateTime;
+export declare function addHours(d: IDateTime, v: number): IDateTime;
+export declare function addMinutes(d: IDateTime, v: number): IDateTime;
+export declare function addSeconds(d: IDateTime, v: number): IDateTime;
+export declare function addMilliseconds(d: IDateTime, v: number): IDateTime;
+export declare function addTicks(d: IDateTime, v: int64): IDateTime;
+export declare function addYears(d: IDateTime, v: number): IDateTime;
+export declare function addMonths(d: IDateTime, v: number): IDateTime;
+export declare function subtract<Input extends number | IDateTime, Output = Input extends number ? IDateTime : number>(d: IDateTime, that: Input): Output;
+export declare function toLongDateString(d: IDateTime): string;
+export declare function toShortDateString(d: IDateTime): string;
+export declare function toLongTimeString(d: IDateTime): string;
+export declare function toShortTimeString(d: IDateTime): string;
+export declare function equals(d1: IDateTime, d2: IDateTime): boolean;
+export declare const compare: typeof compareDates;
+export declare const compareTo: typeof compareDates;
+export declare function op_Addition(x: IDateTime, y: number): IDateTime;
+export declare function op_Subtraction<Input extends number | IDateTime, Output = Input extends number ? IDateTime : number>(x: IDateTime, y: Input): Output;
+export declare function isDaylightSavingTime(x: IDateTime): boolean;
+export default DateTime;