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

package/dist/ts/node_modules/@fable-org/fable-library-js/RegExp.js

@@ -0,0 +1,133 @@
+function create(pattern, options = 0) {
+    // Supported RegexOptions
+    // * IgnoreCase:  0x0001
+    // * Multiline:   0x0002
+    // * Compiled:    0x0008 (ignored)
+    // * Singleline:  0x0010
+    // * ECMAScript:  0x0100 (ignored)
+    if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) !== 0) {
+        throw new Error("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
+    }
+    // Set always global and unicode flags for compatibility with dotnet, see #2925
+    let flags = "gu";
+    flags += options & 1 ? "i" : ""; // 0x0001 RegexOptions.IgnoreCase
+    flags += options & 2 ? "m" : "";
+    flags += options & 16 ? "s" : "";
+    return new RegExp(pattern, flags);
+}
+// From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
+function escape(str) {
+    return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+}
+function unescape(str) {
+    return str.replace(/\\([\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|])/g, "$1");
+}
+function isMatch(reg, input, startAt = 0) {
+    reg.lastIndex = startAt;
+    return reg.test(input);
+}
+function match(reg, input, startAt = 0) {
+    reg.lastIndex = startAt;
+    return reg.exec(input);
+}
+function matches(reg, input, startAt = 0) {
+    if (input == null) {
+        throw new Error("Input cannot ve null");
+    }
+    if (!reg.global) {
+        throw new Error("Non-global RegExp"); // Prevent infinite loop
+    }
+    reg.lastIndex = startAt;
+    const matches = [];
+    let m;
+    let lastMatchIndex = -1;
+    while ((m = reg.exec(input)) != null) {
+        // It can happen even global regex get stuck, see #2845
+        if (m.index === lastMatchIndex) {
+            reg.lastIndex++;
+        }
+        else {
+            lastMatchIndex = m.index;
+            matches.push(m);
+        }
+    }
+    return matches;
+}
+function options(reg) {
+    let options = 256; // ECMAScript
+    options |= reg.ignoreCase ? 1 : 0;
+    options |= reg.multiline ? 2 : 0;
+    return options;
+}
+function replace(reg, input, replacement, limit, offset = 0) {
+    function replacer() {
+        let res = arguments[0];
+        if (limit) {
+            limit--;
+            const match = [];
+            const len = arguments.length;
+            // arguments: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_function_as_a_parameter
+            // * match: matched substring
+            // * p1, p2, ...: nth capture group string
+            // * offset: offset of matched substring
+            // * string: whole string examined
+            // * groups: named capturing groups
+            //           ONLY if regex contains a named capture group AND browser supports named groups
+            // -> last element can be groups OR input string
+            // -> check if last element is string
+            const withGroups = typeof arguments[len - 1] !== "string";
+            let pLast = withGroups ? len - 3 : len - 2;
+            for (let i = 0; i < pLast; i++) {
+                match.push(arguments[i]);
+            }
+            match.index = arguments[pLast++];
+            match.input = arguments[pLast++];
+            if (withGroups) {
+                match.groups = arguments[pLast];
+            }
+            res = replacement(match);
+        }
+        return res;
+    }
+    if (typeof reg === "string") {
+        const tmp = reg;
+        reg = create(input, limit ?? 0);
+        input = tmp;
+        limit = undefined;
+    }
+    if (typeof replacement === "function") {
+        limit = limit == null ? -1 : limit;
+        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);
+    }
+    else {
+        replacement =
+            replacement
+                // $0 doesn't work with JS regex, see #1155
+                .replace(/\$0/g, (_s) => "$&")
+                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)
+                .replace(/\${([^}]+)}/g, "\$<$1>");
+        if (limit != null) {
+            let m;
+            const sub1 = input.substring(offset);
+            const _matches = matches(reg, sub1);
+            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;
+            return input.substring(0, offset) + sub2.replace(reg, replacement)
+                + input.substring(offset + sub2.length);
+        }
+        else {
+            return input.replace(reg, replacement);
+        }
+    }
+}
+function split(reg, input, limit, offset = 0) {
+    if (typeof reg === "string") {
+        const tmp = reg;
+        reg = create(input, limit ?? 0);
+        input = tmp;
+        limit = undefined;
+    }
+    input = input.substring(offset);
+    return input.split(reg, limit);
+}
+
+export { create, escape, isMatch, match, matches, options, replace, split, unescape };

package/dist/ts/node_modules/@fable-org/fable-library-js/Result.js

@@ -0,0 +1,168 @@
+import { Union } from './Types.js';
+import { union_type } from './Reflection.js';
+import { equals } from './Util.js';
+import { singleton, empty } from './List.js';
+import { some } from './Option.js';
+
+function FSharpResult$2_Ok(ResultValue) {
+    return new FSharpResult$2(0, [ResultValue]);
+}
+function FSharpResult$2_Error(ErrorValue) {
+    return new FSharpResult$2(1, [ErrorValue]);
+}
+class FSharpResult$2 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Ok", "Error"];
+    }
+}
+function FSharpResult$2_$reflection(gen0, gen1) {
+    return union_type("FSharp.Core.FSharpResult`2", [gen0, gen1], FSharpResult$2, () => [[["ResultValue", gen0]], [["ErrorValue", gen1]]]);
+}
+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]);
+    }
+}
+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]));
+    }
+}
+function Result_Bind(binder, result) {
+    if (result.tag === /* Ok */ 0) {
+        return binder(result.fields[0]);
+    }
+    else {
+        return FSharpResult$2_Error(result.fields[0]);
+    }
+}
+function Result_IsOk(result) {
+    if (result.tag === /* Ok */ 0) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function Result_IsError(result) {
+    if (result.tag === /* Ok */ 0) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+function Result_Contains(value, result) {
+    if (result.tag === /* Ok */ 0) {
+        return equals(result.fields[0], value);
+    }
+    else {
+        return false;
+    }
+}
+function Result_Count(result) {
+    if (result.tag === /* Ok */ 0) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+function Result_DefaultValue(defaultValue, result) {
+    if (result.tag === /* Ok */ 0) {
+        return result.fields[0];
+    }
+    else {
+        return defaultValue;
+    }
+}
+function Result_DefaultWith(defThunk, result) {
+    if (result.tag === /* Ok */ 0) {
+        return result.fields[0];
+    }
+    else {
+        return defThunk(result.fields[0]);
+    }
+}
+function Result_Exists(predicate, result) {
+    if (result.tag === /* Ok */ 0) {
+        return predicate(result.fields[0]);
+    }
+    else {
+        return false;
+    }
+}
+function Result_Fold(folder, state, result) {
+    if (result.tag === /* Ok */ 0) {
+        return folder(state, result.fields[0]);
+    }
+    else {
+        return state;
+    }
+}
+function Result_FoldBack(folder, result, state) {
+    if (result.tag === /* Ok */ 0) {
+        return folder(result.fields[0], state);
+    }
+    else {
+        return state;
+    }
+}
+function Result_ForAll(predicate, result) {
+    if (result.tag === /* Ok */ 0) {
+        return predicate(result.fields[0]);
+    }
+    else {
+        return true;
+    }
+}
+function Result_Iterate(action, result) {
+    if (result.tag === /* Ok */ 0) {
+        action(result.fields[0]);
+    }
+}
+function Result_ToArray(result) {
+    if (result.tag === /* Ok */ 0) {
+        return [result.fields[0]];
+    }
+    else {
+        return [];
+    }
+}
+function Result_ToList(result) {
+    if (result.tag === /* Ok */ 0) {
+        return singleton(result.fields[0]);
+    }
+    else {
+        return empty();
+    }
+}
+function Result_ToOption(result) {
+    if (result.tag === /* Ok */ 0) {
+        return some(result.fields[0]);
+    }
+    else {
+        return undefined;
+    }
+}
+function Result_ToValueOption(result) {
+    if (result.tag === /* Ok */ 0) {
+        return some(result.fields[0]);
+    }
+    else {
+        return undefined;
+    }
+}
+
+export { FSharpResult$2, FSharpResult$2_$reflection, FSharpResult$2_Error, FSharpResult$2_Ok, Result_Bind, Result_Contains, Result_Count, Result_DefaultValue, Result_DefaultWith, Result_Exists, Result_Fold, Result_FoldBack, Result_ForAll, Result_IsError, Result_IsOk, Result_Iterate, Result_Map, Result_MapError, Result_ToArray, Result_ToList, Result_ToOption, Result_ToValueOption };