@nfdi4plants/arctrl 3.2.3 → 3.3.0

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

@@ -1,7 +1,7 @@
 import { protectedBind, CancellationToken, protectedCont, protectedReturn, OperationCanceledException, Trampoline } from './AsyncBuilder.js';
 import { Choice_makeChoice2Of2, Choice_makeChoice1Of2 } from './Choice.js';
-import { TimeoutException_$ctor } from './System.js';
-import { Exception } from './Util.js';
+import { TimeoutException_$ctor, InvalidOperationException_$ctor_Z721C83C5, ArgumentException_$ctor_Z384F8060 } from './System.js';
+import { Exception, ensureErrorOrException } from './Util.js';
 
 function emptyContinuation(_x) {
 }
@@ -42,27 +42,49 @@ function throwIfCancellationRequested(token) {
     throw new Exception("Operation is cancelled");
   }
 }
+function createLinkedToken(parent) {
+  const token = new CancellationToken();
+  const id = parent.addListener(() => token.cancel());
+  return [token, () => {
+    parent.removeListener(id);
+  }];
+}
 function startChild(computation, ms) {
   return protectedCont((ctx) => {
-    const promise = startAsPromise(computation, ctx.cancelToken);
-    let promiseToRun = promise;
-    if (ms) {
-      promiseToRun = new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
-        promise.then(
-          (value) => {
-            clearTimeout(timeoutId);
-            resolve(value);
-          },
-          (error) => {
-            clearTimeout(timeoutId);
+    const timeout = ms == null || ms === -1 ? void 0 : ms;
+    const [childToken, unlink] = timeout === void 0 ? [ctx.cancelToken, () => {
+    }] : createLinkedToken(ctx.cancelToken);
+    const promise = startAsPromise(computation, childToken);
+    let settled = false;
+    const onSettled = () => {
+      settled = true;
+      unlink();
+    };
+    promise.then(onSettled, onSettled);
+    const awaitResult = () => timeout === void 0 || settled ? promise : new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        if (timeout !== 0) {
+          try {
+            childToken.cancel();
+          } catch (error) {
             reject(error);
+            return;
           }
-        );
-      });
-    }
-    promiseToRun.catch(emptyContinuation);
-    protectedReturn(awaitPromise(promiseToRun))(ctx);
+        }
+        reject(TimeoutException_$ctor());
+      }, timeout);
+      promise.then(
+        (value) => {
+          clearTimeout(timeoutId);
+          resolve(value);
+        },
+        (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        }
+      );
+    });
+    protectedReturn(protectedCont((awaitCtx) => awaitPromise(awaitResult())(awaitCtx)))(ctx);
   });
 }
 function awaitPromise(p) {
@@ -83,6 +105,9 @@ function awaitEvent(event, cancelAction) {
       }
       ctx.onCancel(new OperationCanceledException());
     });
+    if (ctx.cancelToken.isCancelled) {
+      return;
+    }
     event.AddHandler(handler);
   });
 }
@@ -101,14 +126,194 @@ function catchAsync(work) {
     });
   });
 }
+function tryCancelled(computation, compensation) {
+  return (ctx) => {
+    computation({
+      ...ctx,
+      onCancel: (error) => {
+        try {
+          compensation(error);
+        } catch {
+        }
+        if (ctx.trampoline.incrementAndCheck()) {
+          ctx.trampoline.hijack(() => ctx.onCancel(error));
+        } else {
+          ctx.onCancel(error);
+        }
+      }
+    });
+  };
+}
 function fromContinuations(f) {
-  return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+  return (ctx) => {
+    let settled = false;
+    const claim = () => {
+      if (settled) {
+        throw InvalidOperationException_$ctor_Z721C83C5("A continuation was invoked more than once");
+      }
+      settled = true;
+    };
+    const success = (x) => {
+      claim();
+      ctx.onSuccess(x);
+    };
+    const error = (x) => {
+      claim();
+      ctx.onError(x);
+    };
+    const cancelled = (x) => {
+      claim();
+      ctx.onCancel(x);
+    };
+    protectedCont(() => f([success, error, cancelled]))({
+      onSuccess: success,
+      onError: (x) => {
+        if (settled) {
+          throw x;
+        }
+        error(x);
+      },
+      onCancel: cancelled,
+      cancelToken: ctx.cancelToken,
+      trampoline: ctx.trampoline
+    });
+  };
 }
 function ignore(computation) {
   return protectedBind(computation, (_x) => protectedReturn(void 0));
 }
-function parallel(computations) {
-  return protectedCont((ctx) => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w, ctx.cancelToken))))(ctx));
+function parallel(computations, maxDegreeOfParallelism) {
+  if (maxDegreeOfParallelism != null && maxDegreeOfParallelism < 1) {
+    throw ArgumentException_$ctor_Z384F8060(
+      `maxDegreeOfParallelism must be positive, was ${maxDegreeOfParallelism}`,
+      "maxDegreeOfParallelism"
+    );
+  }
+  return protectedCont((ctx) => awaitPromise(runParallel(Array.from(computations), maxDegreeOfParallelism, ctx.cancelToken))(ctx));
+}
+function runParallel(computations, limit, parentToken) {
+  return new Promise((resolve, reject) => {
+    const count = computations.length;
+    const results = new Array(count);
+    const [token, unlink] = createLinkedToken(parentToken);
+    let next = 0;
+    let running = 0;
+    let failed = false;
+    let failure;
+    const startNext = () => {
+      const i = next++;
+      running++;
+      startAsPromise(computations[i], token).then(
+        (x) => {
+          results[i] = x;
+        },
+        (err) => {
+          if (!failed) {
+            failed = true;
+            failure = err;
+            try {
+              token.cancel();
+            } catch (error) {
+              failure = error;
+            }
+          }
+        }
+      ).then(() => {
+        running--;
+        if (!failed && next < count) {
+          startNext();
+        } else if (running === 0) {
+          unlink();
+          if (failed) {
+            reject(failure);
+          } else {
+            resolve(results);
+          }
+        }
+      });
+    };
+    if (count === 0) {
+      unlink();
+      resolve(results);
+    }
+    const initial = Math.min(limit ?? count, count);
+    while (next < initial) {
+      startNext();
+    }
+  });
+}
+function choice(computations) {
+  return protectedCont((ctx) => {
+    const works = Array.from(computations);
+    let remaining = works.length;
+    if (remaining === 0) {
+      ctx.onSuccess(void 0);
+      return;
+    }
+    const [token, unlink] = createLinkedToken(ctx.cancelToken);
+    let done = false;
+    const finish = (report) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      unlink();
+      try {
+        token.cancel();
+      } catch (error) {
+        ctx.onError(ensureErrorOrException(error));
+        return;
+      }
+      report();
+    };
+    for (const work of works) {
+      startWithContinuations(
+        work,
+        (x) => {
+          if (x != null) {
+            finish(() => ctx.onSuccess(x));
+          } else if (--remaining === 0) {
+            finish(() => ctx.onSuccess(void 0));
+          }
+        },
+        (err) => finish(() => ctx.onError(err)),
+        (err) => finish(() => ctx.onCancel(err)),
+        token
+      );
+      if (done) {
+        break;
+      }
+    }
+  });
+}
+function onCancel(interruption) {
+  return protectedCont((ctx) => {
+    const token = ctx.cancelToken;
+    let interrupted = false;
+    const interrupt = () => {
+      if (!interrupted) {
+        interrupted = true;
+        try {
+          interruption();
+        } catch {
+        }
+      }
+    };
+    const id = token.addListener(interrupt);
+    let disposed = false;
+    ctx.onSuccess({
+      Dispose() {
+        if (disposed) {
+          return;
+        }
+        disposed = true;
+        token.removeListener(id);
+        if (token.isCancelled) {
+          interrupt();
+        }
+      }
+    });
+  });
 }
 function sequential(computations) {
   function _sequential(computations2, cancelToken) {
@@ -122,15 +327,25 @@ function sequential(computations) {
 }
 function sleep(millisecondsDueTime) {
   return protectedCont((ctx) => {
+    let completed = false;
     let tokenId;
-    const timeoutId = setTimeout(() => {
-      ctx.cancelToken.removeListener(tokenId);
-      ctx.onSuccess(void 0);
-    }, millisecondsDueTime);
-    tokenId = ctx.cancelToken.addListener(() => {
+    const settle = (cancelled) => {
+      if (completed) {
+        return;
+      }
+      completed = true;
       clearTimeout(timeoutId);
-      ctx.onCancel(new OperationCanceledException());
-    });
+      if (tokenId !== void 0) {
+        ctx.cancelToken.removeListener(tokenId);
+      }
+      if (cancelled) {
+        ctx.onCancel(new OperationCanceledException());
+      } else {
+        ctx.onSuccess(void 0);
+      }
+    };
+    const timeoutId = setTimeout(() => settle(false), millisecondsDueTime);
+    tokenId = ctx.cancelToken.addListener(() => settle(true));
   });
 }
 function start(computation, cancellationToken2) {
@@ -170,5 +385,11 @@ function startAsPromise(computation, cancellationToken2) {
     cancellationToken2 ? cancellationToken2 : defaultCancellationToken
   ));
 }
+function startAsTask(computation, _taskCreationOptions, cancellationToken2) {
+  return startAsPromise(computation, cancellationToken2);
+}
+function startImmediateAsTask(computation, cancellationToken2) {
+  return startAsPromise(computation, cancellationToken2);
+}
 
-export { awaitEvent, awaitPromise, bind, callThenInvoke, cancel, cancelAfter, cancellationToken, catchAsync, createCancellationToken, defaultCancellationToken, fromContinuations, ignore, invoke, isCancellationRequested, makeAsync, parallel, sequential, sleep, start, startAsPromise, startChild, startImmediate, startWithContinuations, throwIfCancellationRequested };
+export { awaitEvent, awaitPromise, bind, callThenInvoke, cancel, cancelAfter, cancellationToken, catchAsync, choice, createCancellationToken, defaultCancellationToken, fromContinuations, ignore, invoke, isCancellationRequested, makeAsync, onCancel, parallel, sequential, sleep, start, startAsPromise, startAsTask, startChild, startImmediate, startImmediateAsTask, startWithContinuations, throwIfCancellationRequested, tryCancelled };

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

@@ -1,5 +1,11 @@
 import { Exception, ensureErrorOrException } from './Util.js';
 
+class CancellationCallbackError extends Exception {
+  constructor(errors) {
+    super("Cancellation callbacks failed", errors[0]);
+    this.errors = errors;
+  }
+}
 class CancellationToken {
   constructor(cancelled = false) {
     this._id = 0;
@@ -12,14 +18,32 @@ class CancellationToken {
   cancel() {
     if (!this._cancelled) {
       this._cancelled = true;
-      for (const [, listener] of this._listeners) {
-        listener();
+      const pending = Array.from(this._listeners.keys()).reverse();
+      const errors = [];
+      for (const id of pending) {
+        const listener = this._listeners.get(id);
+        this._listeners.delete(id);
+        if (listener) {
+          try {
+            listener();
+          } catch (error) {
+            errors.push(error);
+          }
+        }
+      }
+      if (errors.length > 0) {
+        throw new CancellationCallbackError(errors);
       }
     }
   }
   addListener(f) {
     const id = this._id;
-    this._listeners.set(this._id++, f);
+    this._id++;
+    if (this._cancelled) {
+      f();
+    } else {
+      this._listeners.set(id, f);
+    }
     return id;
   }
   removeListener(id) {
@@ -132,24 +156,50 @@ class AsyncBuilder {
     return computation;
   }
   TryFinally(computation, compensation) {
-    return protectedCont((ctx) => {
-      computation({
+    return (ctx) => {
+      let settled = false;
+      protectedCont(computation)({
         onSuccess: (x) => {
-          compensation();
+          if (settled) {
+            return;
+          }
+          settled = true;
+          try {
+            compensation();
+          } catch (error) {
+            ctx.onError(ensureErrorOrException(error));
+            return;
+          }
           ctx.onSuccess(x);
         },
         onError: (x) => {
-          compensation();
+          if (settled) {
+            throw x;
+          }
+          settled = true;
+          try {
+            compensation();
+          } catch (error) {
+            ctx.onError(ensureErrorOrException(error));
+            return;
+          }
           ctx.onError(x);
         },
         onCancel: (x) => {
-          compensation();
+          if (settled) {
+            return;
+          }
+          settled = true;
+          try {
+            compensation();
+          } catch {
+          }
           ctx.onCancel(x);
         },
         cancelToken: ctx.cancelToken,
         trampoline: ctx.trampoline
       });
-    });
+    };
   }
   TryWith(computation, catchHandler) {
     return protectedCont((ctx) => {
@@ -172,7 +222,7 @@ class AsyncBuilder {
     });
   }
   Using(resource, binder) {
-    return this.TryFinally(binder(resource), () => resource.Dispose());
+    return this.TryFinally(this.Delay(() => binder(resource)), () => resource.Dispose());
   }
   While(guard, computation) {
     if (guard()) {
@@ -187,4 +237,4 @@ class AsyncBuilder {
 }
 const singleton = new AsyncBuilder();
 
-export { AsyncBuilder, CancellationToken, OperationCanceledException, Trampoline, protectedBind, protectedCont, protectedReturn, singleton };
+export { AsyncBuilder, CancellationCallbackError, CancellationToken, OperationCanceledException, Trampoline, protectedBind, protectedCont, protectedReturn, singleton };

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

@@ -1,5 +1,7 @@
+import { FSharpRef } from './Types.js';
 import { truncate, fromParts } from './Decimal.js';
 import { bigintHash, Exception } from './Util.js';
+import { ArgumentNullException_$ctor_Z721C83C5, FormatException_$ctor_Z721C83C5 } from './System.js';
 
 const isBigEndian = false;
 BigInt.prototype.toJSON = function() {
@@ -344,16 +346,24 @@ function toChar(x) {
 function toString(x) {
   return x.toString();
 }
+const integerRegex = /^[\t-\r ]*([+-]?\d+)[\t-\r ]*\0*$/;
 function tryParse(s, res) {
-  try {
-    res.contents = BigInt(s);
+  const m = s == null ? null : integerRegex.exec(s);
+  if (m != null) {
+    res.contents = BigInt(m[1]);
     return true;
-  } catch (err) {
-    return false;
   }
+  return false;
 }
 function parse(s) {
-  return BigInt(s);
+  const res = new FSharpRef(zero);
+  if (tryParse(s, res)) {
+    return res.contents;
+  } else if (s == null) {
+    throw ArgumentNullException_$ctor_Z721C83C5("value");
+  } else {
+    throw FormatException_$ctor_Z721C83C5("The value could not be parsed.");
+  }
 }
 function pow(x, n) {
   return x ** BigInt(n);

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

@@ -0,0 +1,139 @@
+const littleEndian = true;
+function isLittleEndian() {
+  return littleEndian;
+}
+function getBytesBoolean(value) {
+  const bytes = new Uint8Array(1);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setUint8(0, value ? 1 : 0);
+  return bytes;
+}
+function getBytesChar(value) {
+  const bytes = new Uint8Array(2);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setUint16(0, value.charCodeAt(0), littleEndian);
+  return bytes;
+}
+function getBytesInt16(value) {
+  const bytes = new Uint8Array(2);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setInt16(0, value, littleEndian);
+  return bytes;
+}
+function getBytesInt32(value) {
+  const bytes = new Uint8Array(4);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setInt32(0, value, littleEndian);
+  return bytes;
+}
+function getBytesInt64(value) {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setBigInt64(0, value, littleEndian);
+  return bytes;
+}
+function getBytesUInt16(value) {
+  const bytes = new Uint8Array(2);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setUint16(0, value, littleEndian);
+  return bytes;
+}
+function getBytesUInt32(value) {
+  const bytes = new Uint8Array(4);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setUint32(0, value, littleEndian);
+  return bytes;
+}
+function getBytesUInt64(value) {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setBigUint64(0, value, littleEndian);
+  return bytes;
+}
+function getBytesSingle(value) {
+  const bytes = new Uint8Array(4);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setFloat32(0, value, littleEndian);
+  return bytes;
+}
+function getBytesDouble(value) {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setFloat64(0, value, littleEndian);
+  return bytes;
+}
+function int64BitsToDouble(value) {
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setBigInt64(0, value, littleEndian);
+  return view.getFloat64(0, littleEndian);
+}
+function doubleToInt64Bits(value) {
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setFloat64(0, value, littleEndian);
+  return view.getBigInt64(0, littleEndian);
+}
+function toBoolean(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getUint8(offset) !== 0;
+}
+function toChar(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  const code = view.getUint16(offset, littleEndian);
+  return String.fromCharCode(code);
+}
+function toInt16(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getInt16(offset, littleEndian);
+}
+function toInt32(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getInt32(offset, littleEndian);
+}
+function toInt64(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getBigInt64(offset, littleEndian);
+}
+function toUInt16(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getUint16(offset, littleEndian);
+}
+function toUInt32(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getUint32(offset, littleEndian);
+}
+function toUInt64(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getBigUint64(offset, littleEndian);
+}
+function toSingle(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getFloat32(offset, littleEndian);
+}
+function toDouble(bytes, offset) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  return view.getFloat64(offset, littleEndian);
+}
+function toString(bytes, offset, count) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+  if (offset != null && count != null) {
+    buffer = buffer.subarray(offset, offset + count);
+  } else if (offset != null) {
+    buffer = buffer.subarray(offset);
+  }
+  return Array.from(buffer).map((b) => ("0" + b.toString(16)).slice(-2).toUpperCase()).join("-");
+}
+
+export { doubleToInt64Bits, getBytesBoolean, getBytesChar, getBytesDouble, getBytesInt16, getBytesInt32, getBytesInt64, getBytesSingle, getBytesUInt16, getBytesUInt32, getBytesUInt64, int64BitsToDouble, isLittleEndian, toBoolean, toChar, toDouble, toInt16, toInt32, toInt64, toSingle, toString, toUInt16, toUInt32, toUInt64 };

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

@@ -371,7 +371,7 @@ function dateToISOStringWithOffset(dateWithOffset, offset) {
   return str.substring(0, str.length - 1) + dateOffsetToString(offset);
 }
 function dateToStringWithOffset(date2, format) {
-  const d = new Date(date2.getTime() + (date2.offset ?? 0));
+  const d = DateTime(date2.getTime() + (date2.offset ?? 0), DateTimeKind.Utc);
   if (typeof format !== "string") {
     return d.toISOString().replace(/\.\d+/, "").replace(/[A-Z]|\.\d+/g, " ") + dateOffsetToString(date2.offset ?? 0);
   } else if (format.length === 1) {