@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

package/README.md

@@ -3,6 +3,8 @@
 
 # ARCtrl
 
+[![DOI](https://img.shields.io/badge/Cite%20Us-10.5281%2Fzenodo.15194394-008273?logo=zenodo&logoColor=C70039)](https://doi.org/10.5281/zenodo.15194394)
+
 > **ARCtrl** the easy way to read, manipulate and write ARCs in __.NET__, __JavaScript__ and __Python__! ❤️
 
 | Version | Downloads |

package/dist/ts/index.d.ts

@@ -0,0 +1,61 @@
+import { LDNode, LDGraph, LDRef, LDValue } from './ts/ROCrate/LDObject.js';
+import { LDContext } from './ts/ROCrate/LDContext.js';
+import { initV1_1, initV1_2DRAFT, initBioschemasContext } from './ts/ROCrate/ROCrateContext.js';
+import { LDComment } from './ts/ROCrate/Generic/Comment.js';
+import { LDDefinedTerm } from './ts/ROCrate/Generic/DefinedTerm.js';
+import { LDFile } from './ts/ROCrate/Generic/File.js';
+import { LDLabProcess } from './ts/ROCrate/Generic/LabProcess.js';
+import { LDLabProtocol } from './ts/ROCrate/Generic/LabProtocol.js';
+import { LDOrganization } from './ts/ROCrate/Generic/Organization.js';
+import { LDPerson } from './ts/ROCrate/Generic/Person.js';
+import { LDPostalAddress } from './ts/ROCrate/Generic/PostalAddress.js';
+import { LDPropertyValue } from './ts/ROCrate/Generic/PropertyValue.js';
+import { LDSample } from './ts/ROCrate/Generic/Sample.js';
+import { LDScholarlyArticle } from './ts/ROCrate/Generic/ScholarlyArticle.js';
+import { LDDataset } from './ts/ROCrate/Generic/Dataset.js';
+import { LDGraphExtensions_PyJsInterop as LDGraphIO, LDNodeExtensions_PyJsInterop as LDNodeIO } from './ts/JsonIO/LDObject.js';
+import { TypeExtensions_Conversion as Conversion } from './ts/Conversion.js';
+export { ARC } from './ts/ARC.js';
+export { ArcAssay, ArcStudy, ArcRun, ArcWorkflow, ArcInvestigation } from './ts/Core/ArcTypes.js';
+export { CompositeCell } from './ts/Core/Table/CompositeCell.js';
+export { CompositeHeader, IOType } from './ts/Core/Table/CompositeHeader.js';
+export { CompositeColumn } from './ts/Core/Table/CompositeColumn.js';
+export { ArcTable } from './ts/Core/Table/ArcTable.js';
+export { Template, Organisation } from './ts/Core/Template.js';
+export { Templates } from './ts/Core/Templates.js';
+export { JsonController } from './ts/Json.js';
+export { XlsxController } from './ts/Xlsx.js';
+export { Person } from './ts/Core/Person.js';
+export { Publication } from './ts/Core/Publication.js';
+export { OntologyAnnotation } from './ts/Core/OntologyAnnotation.js';
+export { Comment$ as Comment } from './ts/Core/Comment.js';
+export { Contract } from './ts/Contract/Contract.js';
+export { WebController } from './ts/Template.Web.js';
+export { FileSystem } from './ts/FileSystem/FileSystem.js';
+export { FileSystemTree } from './ts/FileSystem/FileSystemTree.js';
+export declare const ROCrate: {
+    LDNode: typeof LDNode;
+    LDGraph: typeof LDGraph;
+    LDValue: typeof LDValue;
+    LDRef: typeof LDRef;
+    LDContext: typeof LDContext;
+    initV1_1: typeof initV1_1;
+    initV1_2DRAFT: typeof initV1_2DRAFT;
+    initBioschemasContext: typeof initBioschemasContext;
+    LDComment: typeof LDComment;
+    LDDefinedTerm: typeof LDDefinedTerm;
+    LDFile: typeof LDFile;
+    LDLabProcess: typeof LDLabProcess;
+    LDLabProtocol: typeof LDLabProtocol;
+    LDOrganization: typeof LDOrganization;
+    LDPerson: typeof LDPerson;
+    LDPostalAddress: typeof LDPostalAddress;
+    LDPropertyValue: typeof LDPropertyValue;
+    LDSample: typeof LDSample;
+    LDScholarlyArticle: typeof LDScholarlyArticle;
+    LDDataset: typeof LDDataset;
+    LDGraphIO: typeof LDGraphIO;
+    LDNodeIO: typeof LDNodeIO;
+    Conversion: typeof Conversion;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/ts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ARCtrl/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACjG,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAA;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AACtD,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACpE,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAE,aAAa,EAAC,MAAM,sBAAsB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAGlE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAC,MAAM,0BAA0B,CAAA;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAA;AAC/F,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAA;AACnE,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAA;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAA;AACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAA;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAA;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,6BAA6B,IAAI,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACpF,OAAO,EAAE,4BAA4B,IAAI,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClF,OAAO,EAAE,yBAAyB,IAAI,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE5E,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAwBnB,CAAC"}

package/dist/ts/index.js

@@ -0,0 +1,63 @@
+export { ARC } from './ts/ARC.js';
+export { ArcAssay, ArcInvestigation, ArcRun, ArcStudy, ArcWorkflow } from './ts/Core/ArcTypes.js';
+export { CompositeCell } from './ts/Core/Table/CompositeCell.js';
+export { CompositeHeader, IOType } from './ts/Core/Table/CompositeHeader.js';
+export { CompositeColumn } from './ts/Core/Table/CompositeColumn.js';
+export { ArcTable } from './ts/Core/Table/ArcTable.js';
+export { Organisation, Template } from './ts/Core/Template.js';
+export { Templates } from './ts/Core/Templates.js';
+export { JsonController } from './ts/Json.js';
+export { XlsxController } from './ts/Xlsx.js';
+export { Person } from './ts/Core/Person.js';
+export { Publication } from './ts/Core/Publication.js';
+export { OntologyAnnotation } from './ts/Core/OntologyAnnotation.js';
+export { Comment$ as Comment } from './ts/Core/Comment.js';
+export { Contract } from './ts/Contract/Contract.js';
+export { WebController } from './ts/Template.Web.js';
+export { FileSystem } from './ts/FileSystem/FileSystem.js';
+export { FileSystemTree } from './ts/FileSystem/FileSystemTree.js';
+import { LDRef, LDValue, LDGraph, LDNode } from './ts/ROCrate/LDObject.js';
+import { LDContext } from './ts/ROCrate/LDContext.js';
+import { initBioschemasContext, initV1_2DRAFT, initV1_1 } from './ts/ROCrate/ROCrateContext.js';
+import { LDComment } from './ts/ROCrate/Generic/Comment.js';
+import { LDDefinedTerm } from './ts/ROCrate/Generic/DefinedTerm.js';
+import { LDFile } from './ts/ROCrate/Generic/File.js';
+import { LDLabProcess } from './ts/ROCrate/Generic/LabProcess.js';
+import { LDLabProtocol } from './ts/ROCrate/Generic/LabProtocol.js';
+import { LDOrganization } from './ts/ROCrate/Generic/Organization.js';
+import { LDPerson } from './ts/ROCrate/Generic/Person.js';
+import { LDPostalAddress } from './ts/ROCrate/Generic/PostalAddress.js';
+import { LDPropertyValue } from './ts/ROCrate/Generic/PropertyValue.js';
+import { LDSample } from './ts/ROCrate/Generic/Sample.js';
+import { LDScholarlyArticle } from './ts/ROCrate/Generic/ScholarlyArticle.js';
+import { LDDataset } from './ts/ROCrate/Generic/Dataset.js';
+import { LDNodeExtensions_PyJsInterop, LDGraphExtensions_PyJsInterop } from './ts/JsonIO/LDObject.js';
+import { TypeExtensions_Conversion } from './ts/Conversion.js';
+
+const ROCrate = {
+  LDNode,
+  LDGraph,
+  LDValue,
+  LDRef,
+  LDContext,
+  initV1_1,
+  initV1_2DRAFT,
+  initBioschemasContext,
+  LDComment,
+  LDDefinedTerm,
+  LDFile,
+  LDLabProcess,
+  LDLabProtocol,
+  LDOrganization,
+  LDPerson,
+  LDPostalAddress,
+  LDPropertyValue,
+  LDSample,
+  LDScholarlyArticle,
+  LDDataset,
+  LDGraphIO: LDGraphExtensions_PyJsInterop,
+  LDNodeIO: LDNodeExtensions_PyJsInterop,
+  Conversion: TypeExtensions_Conversion
+};
+
+export { ROCrate };

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

@@ -0,0 +1,354 @@
+import { Helpers_allocateArrayFromCons } from './Native.js';
+import { value, some, defaultArg, map as map$1 } from './Option.js';
+import { equals, defaultOf, getEnumerator, disposeSafe } from './Util.js';
+
+function differentLengths() {
+    throw new Error("Arrays had different lengths");
+}
+function append(array1, array2, cons) {
+    const len1 = array1.length | 0;
+    const len2 = array2.length | 0;
+    const newArray = Helpers_allocateArrayFromCons(cons, len1 + len2);
+    for (let i = 0; i <= (len1 - 1); i++) {
+        setItem(newArray, i, item(i, array1));
+    }
+    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {
+        setItem(newArray, i_1 + len1, item(i_1, array2));
+    }
+    return newArray;
+}
+function fill(target, targetIndex, count, value) {
+    const start = targetIndex | 0;
+    return target.fill(value, start, (start + count));
+}
+function mapIndexed(f, source, cons) {
+    const len = source.length | 0;
+    const target = Helpers_allocateArrayFromCons(cons, len);
+    for (let i = 0; i <= (len - 1); i++) {
+        setItem(target, i, f(i, item(i, source)));
+    }
+    return target;
+}
+function map(f, source, cons) {
+    const len = source.length | 0;
+    const target = Helpers_allocateArrayFromCons(cons, len);
+    for (let i = 0; i <= (len - 1); i++) {
+        setItem(target, i, f(item(i, source)));
+    }
+    return target;
+}
+function map3(f, source1, source2, source3, cons) {
+    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {
+        throw new Error("Arrays had different lengths");
+    }
+    const result = Helpers_allocateArrayFromCons(cons, source1.length);
+    for (let i = 0; i <= (source1.length - 1); i++) {
+        setItem(result, i, f(item(i, source1), item(i, source2), item(i, source3)));
+    }
+    return result;
+}
+function concat(arrays, cons) {
+    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));
+    const matchValue = arrays_1.length | 0;
+    switch (matchValue) {
+        case 0:
+            return Helpers_allocateArrayFromCons(cons, 0);
+        case 1:
+            return item(0, arrays_1);
+        default: {
+            let totalIdx = 0;
+            let totalLength = 0;
+            for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {
+                const arr_1 = item(idx, arrays_1);
+                totalLength = ((totalLength + arr_1.length) | 0);
+            }
+            const result = Helpers_allocateArrayFromCons(cons, totalLength);
+            for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {
+                const arr_2 = item(idx_1, arrays_1);
+                for (let j = 0; j <= (arr_2.length - 1); j++) {
+                    setItem(result, totalIdx, item(j, arr_2));
+                    totalIdx = ((totalIdx + 1) | 0);
+                }
+            }
+            return result;
+        }
+    }
+}
+function collect(mapping, array, cons) {
+    return concat(map(mapping, array, defaultOf()), cons);
+}
+function indexOf(array, item_1, start, count, eq) {
+    const start_1 = defaultArg(start, 0) | 0;
+    const end$0027 = defaultArg(map$1((c) => (start_1 + c), count), array.length) | 0;
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i >= end$0027) {
+                return -1;
+            }
+            else if (eq.Equals(item_1, item(i, array))) {
+                return i | 0;
+            }
+            else {
+                i_mut = (i + 1);
+                continue loop;
+            }
+        }
+    };
+    return loop(start_1) | 0;
+}
+function contains(value, array, eq) {
+    return indexOf(array, value, undefined, undefined, eq) >= 0;
+}
+function singleton(value, cons) {
+    const ar = Helpers_allocateArrayFromCons(cons, 1);
+    setItem(ar, 0, value);
+    return ar;
+}
+function initialize(count, initializer, cons) {
+    if (count < 0) {
+        throw new Error("The input must be non-negative\\nParameter name: count");
+    }
+    const result = Helpers_allocateArrayFromCons(cons, count);
+    for (let i = 0; i <= (count - 1); i++) {
+        setItem(result, i, initializer(i));
+    }
+    return result;
+}
+function skip(count, array, cons) {
+    if (count > array.length) {
+        throw new Error("count is greater than array length\\nParameter name: count");
+    }
+    if (count === array.length) {
+        return Helpers_allocateArrayFromCons(cons, 0);
+    }
+    else {
+        const count_1 = (count) | 0;
+        return array.slice(count_1);
+    }
+}
+function addInPlace(x, array) {
+    array.push(x);
+}
+function addRangeInPlace(range, array) {
+    const enumerator = getEnumerator(range);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            addInPlace(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), array);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+function insertRangeInPlace(index, range, array) {
+    let index_1;
+    let i = index;
+    const enumerator = getEnumerator(range);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const x = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            (index_1 = (i | 0), array.splice(index_1, 0, x));
+            i = ((i + 1) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+function removeInPlace(item_1, array, eq) {
+    const i = indexOf(array, item_1, undefined, undefined, eq) | 0;
+    if (i > -1) {
+        array.splice(i, 1);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function tryFind(predicate, array) {
+    return array.find(predicate);
+}
+function tryFindIndex(predicate, array) {
+    const matchValue = (array.findIndex(predicate)) | 0;
+    if (matchValue > -1) {
+        return matchValue;
+    }
+    else {
+        return undefined;
+    }
+}
+function tryPick(chooser, array) {
+    const loop = (i_mut) => {
+        loop: while (true) {
+            const i = i_mut;
+            if (i >= array.length) {
+                return undefined;
+            }
+            else {
+                const matchValue = chooser(item(i, array));
+                if (matchValue == null) {
+                    i_mut = (i + 1);
+                    continue loop;
+                }
+                else {
+                    return matchValue;
+                }
+            }
+        }
+    };
+    return loop(0);
+}
+function choose(chooser, array, cons) {
+    const res = [];
+    for (let i = 0; i <= (array.length - 1); i++) {
+        const matchValue = chooser(item(i, array));
+        if (matchValue != null) {
+            const y = value(matchValue);
+            res.push(y);
+        }
+    }
+    if (equals(cons, defaultOf())) {
+        return res;
+    }
+    else {
+        return map((x) => x, res, cons);
+    }
+}
+function fold(folder, state, array) {
+    const folder_1 = folder;
+    return array.reduce((folder_1), state);
+}
+function iterateIndexed(action, array) {
+    for (let i = 0; i <= (array.length - 1); i++) {
+        action(i, item(i, array));
+    }
+}
+function forAll(predicate, array) {
+    return array.every(predicate);
+}
+function sortBy(projection, xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => comparer.Compare(projection(x), projection(y)));
+    return xs_1;
+}
+function sortDescending(xs, comparer) {
+    const xs_1 = xs.slice();
+    xs_1.sort((x, y) => (comparer.Compare(x, y) * -1));
+    return xs_1;
+}
+function unzip(array) {
+    const len = array.length | 0;
+    const res1 = new Array(len);
+    const res2 = new Array(len);
+    iterateIndexed((i, tupledArg) => {
+        setItem(res1, i, tupledArg[0]);
+        setItem(res2, i, tupledArg[1]);
+    }, array);
+    return [res1, res2];
+}
+function equalsWith(equals, array1, array2) {
+    if (array1 == null) {
+        if (array2 == null) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    else if (array2 == null) {
+        return false;
+    }
+    else {
+        let i = 0;
+        let result = true;
+        const length1 = array1.length | 0;
+        const length2 = array2.length | 0;
+        if (length1 > length2) {
+            return false;
+        }
+        else if (length1 < length2) {
+            return false;
+        }
+        else {
+            while ((i < length1) && result) {
+                result = equals(item(i, array1), item(i, array2));
+                i = ((i + 1) | 0);
+            }
+            return result;
+        }
+    }
+}
+function head(array) {
+    if (array.length === 0) {
+        throw new Error("The input array was empty\\nParameter name: array");
+    }
+    else {
+        return item(0, array);
+    }
+}
+function tryHead(array) {
+    if (array.length === 0) {
+        return undefined;
+    }
+    else {
+        return some(item(0, array));
+    }
+}
+function tail(array) {
+    if (array.length === 0) {
+        throw new Error("Not enough elements\\nParameter name: array");
+    }
+    return array.slice(1);
+}
+function item(index, array) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        return array[index];
+    }
+}
+function setItem(array, index, value) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        throw new Error("Index was outside the bounds of the array.\\nParameter name: index");
+    }
+    else {
+        array[index] = value;
+    }
+}
+function tryItem(index, array) {
+    if ((index < 0) ? true : (index >= array.length)) {
+        return undefined;
+    }
+    else {
+        return some(array[index]);
+    }
+}
+function foldBack(folder, array, state) {
+    return array.reduceRight(((delegateArg, delegateArg_1) => folder(delegateArg_1, delegateArg)), state);
+}
+function transpose(arrays, cons) {
+    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));
+    const len = arrays_1.length | 0;
+    if (len === 0) {
+        return new Array(0);
+    }
+    else {
+        const firstArray = item(0, arrays_1);
+        const lenInner = firstArray.length | 0;
+        if (!forAll((a) => (a.length === lenInner), arrays_1)) {
+            differentLengths();
+        }
+        const result = new Array(lenInner);
+        for (let i = 0; i <= (lenInner - 1); i++) {
+            setItem(result, i, Helpers_allocateArrayFromCons(cons, len));
+            for (let j = 0; j <= (len - 1); j++) {
+                item(i, result)[j] = item(i, item(j, arrays_1));
+            }
+        }
+        return result;
+    }
+}
+
+export { addInPlace, addRangeInPlace, append, choose, collect, concat, contains, equalsWith, fill, fold, foldBack, forAll, head, indexOf, initialize, insertRangeInPlace, item, iterateIndexed, map, map3, mapIndexed, removeInPlace, setItem, singleton, skip, sortBy, sortDescending, tail, transpose, tryFind, tryFindIndex, tryHead, tryItem, tryPick, unzip };

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

@@ -0,0 +1,28 @@
+import { Trampoline, CancellationToken, protectedCont, OperationCanceledError } from './AsyncBuilder.js';
+
+function emptyContinuation(_x) {
+    // NOP
+}
+function awaitPromise(p) {
+    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError
+        ? conts[2] : conts[1])(err)));
+}
+const defaultCancellationToken = new CancellationToken();
+function fromContinuations(f) {
+    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
+}
+function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
+    const trampoline = new Trampoline();
+    computation({
+        onSuccess: continuation ? continuation : emptyContinuation,
+        onError: exceptionContinuation,
+        onCancel: cancellationContinuation,
+        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
+        trampoline,
+    });
+}
+function startAsPromise(computation, cancellationToken) {
+    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, defaultCancellationToken));
+}
+
+export { awaitPromise, defaultCancellationToken, fromContinuations, startAsPromise, startWithContinuations };